Promote AgentCompany-New to the repository root and retire the old app

The legacy application - its src, tests, landing site, promo assets, docs,
release tooling, CI workflows, and root configs - leaves the tree; it stays
reachable in history. Everything under AgentCompany-New moves up unchanged:
same package name, so the production userData/database path is untouched,
and e2e/build scripts already resolved paths relative to the project. The
developer cred.txt stays gitignored at its new location. Full verify:ci
passes from the new root.
This commit is contained in:
ZacharyZhang-NY committed 2026-07-07 00:04:13 -04:00
1 parent 2350f744e3
commit 07d0b4587d
1904 files changed
+1133 -282075

No files matched your search

+140 -164
View File
@@ -1,173 +1,149 @@
import type { DatabaseSync } from "node:sqlite";
import log from "electron-log/main.js";
import {
BASELINE_SCHEMA_VERSION,
assertBaselineSchema,
installBaselineSchema,
} from "./migrations/baseline-v56";
import {
markBaselineSchema,
upgradeLegacyProfileToBaselineV56,
} from "./migrations/legacy-to-v56";
import {
TASK_LEASE_SCHEMA_VERSION,
assertTaskLeasesV57,
migrateTaskLeasesV57,
} from "./migrations/v57-task-leases";
import {
APPROVAL_POLICY_SCHEMA_VERSION,
assertApprovalPoliciesV58,
migrateApprovalPoliciesV58,
} from "./migrations/v58-approval-policies";
import {
SOCIAL_COMPANY_SCOPE_SCHEMA_VERSION,
assertSocialCompanyScopeV59,
migrateSocialCompanyScopeV59,
} from "./migrations/v59-social-company-scope";
import {
FILESYSTEM_TASK_WORKSPACES_SCHEMA_VERSION,
assertFilesystemTaskWorkspacesV60,
migrateFilesystemTaskWorkspacesV60,
} from "./migrations/v60-filesystem-task-workspaces";
import {
type ReadAll,
type Transaction,
} from "./migrations/types";
import { initialEnterpriseSchema } from "./migrations/001-initial";
import { collaborationProviderPolicySchema } from "./migrations/002-collaboration";
import { onboardingExecutionSchema } from "./migrations/003-onboarding";
import { filesPinnedAndScheduledPosts } from "./migrations/004-files-posts";
import { chatReadState } from "./migrations/005-chat-read-state";
import { appStateSchema } from "./migrations/006-app-state";
import { skillHardeningSchema } from "./migrations/007-skill-hardening";
import { providerHealthSchema } from "./migrations/008-provider-health";
import { socialGovernanceSchema } from "./migrations/009-social-governance";
import { fileHandoffSecuritySchema } from "./migrations/010-file-handoff-security";
import { boardInterventionSchema } from "./migrations/011-board-interventions";
import { complianceControlsSchema } from "./migrations/012-compliance-controls";
import { searchDocumentsSchema } from "./migrations/013-search-documents";
import { providerPolicyUsageSchema } from "./migrations/014-provider-policy-usage";
import { identityAccessSchema } from "./migrations/015-identity-access";
import { orgGovernanceSchema } from "./migrations/016-org-governance";
import { operationsControlsSchema } from "./migrations/017-operations-controls";
import { sdlcControlsSchema } from "./migrations/018-sdlc-controls";
import { auditReplaySchema } from "./migrations/019-audit-replay";
import { rollbackSnapshotsSchema } from "./migrations/020-rollback-snapshots";
import { providerAuthBrokerSchema } from "./migrations/021-provider-auth-broker";
import { providerRateLimitObservationSchema } from "./migrations/022-provider-rate-limit-observations";
import { providerRequestRuntimeSchema } from "./migrations/023-provider-request-runtime";
import { taskRunProviderRequestSchema } from "./migrations/024-task-run-provider-request";
import { chatMessageDeliverySchema } from "./migrations/025-chat-message-delivery";
import { browserPlatformGovernanceSchema } from "./migrations/026-browser-platform-governance";
import { socialAuditRecordsSchema } from "./migrations/027-social-audit-records";
import { migrationCutoverJournalSchema } from "./migrations/028-migration-cutover-journal";
import { fileHandoffRecordsSchema } from "./migrations/029-file-handoff-records";
import { approvalSourceRefsSchema } from "./migrations/030-approval-source-refs";
import { providerRequestWorkspaceSchema } from "./migrations/031-provider-request-workspace";
import { browserActionMetadataSchema } from "./migrations/032-browser-action-metadata";
import { auditEventImmutabilitySchema } from "./migrations/033-audit-event-immutability";
import { providerAuthSessionsSchema } from "./migrations/034-provider-auth-sessions";
import { taskRunIsolationSchema } from "./migrations/035-task-run-isolation";
import { additionalConnectorsSchema } from "./migrations/036-additional-connectors";
import { customProvidersSchema } from "./migrations/037-custom-providers";
import { providerAuthProfileCascadeSchema } from "./migrations/038-provider-auth-profile-cascade";
import { auditImmutabilityOrgTeardownSchema } from "./migrations/039-audit-immutability-org-teardown";
import { documentsKnowledgeAutomationSchema } from "./migrations/040-documents-knowledge-automation";
import { taskSubtasksDeleteSchema } from "./migrations/041-task-subtasks-delete";
import { approvalNotesMeetingsSprintsSchema } from "./migrations/042-approval-notes-meetings-sprints";
import { composioIntegrationSchema } from "./migrations/043-composio-integration";
import { mentionWakeStateSchema } from "./migrations/044-mention-wake-state";
import { connectorGrantsSchema } from "./migrations/045-connector-grants";
const LATEST_SCHEMA_VERSION = FILESYSTEM_TASK_WORKSPACES_SCHEMA_VERSION;
export function initializeDatabase(
db: DatabaseSync,
ra: ReadAll,
tx: Transaction,
createAutomaticBackup: (reason: string) => string,
): void {
db.exec("create table if not exists schema_migrations (version integer primary key, name text not null, applied_at text not null)");
const currentVersion = currentSchemaVersion(db);
if (currentVersion > LATEST_SCHEMA_VERSION) {
throw new Error(`Profile schema version ${currentVersion} is newer than this app schema ${LATEST_SCHEMA_VERSION}.`);
}
if (currentVersion === LATEST_SCHEMA_VERSION) {
tx(() => {
seedSettings(db);
assertTaskLeasesV57(db);
assertApprovalPoliciesV58(db);
assertSocialCompanyScopeV59(db);
assertFilesystemTaskWorkspacesV60(db);
});
return;
}
if (currentVersion === SOCIAL_COMPANY_SCOPE_SCHEMA_VERSION) {
tx(() => {
seedSettings(db);
assertTaskLeasesV57(db);
assertApprovalPoliciesV58(db);
assertSocialCompanyScopeV59(db);
migrateFilesystemTaskWorkspacesV60(db);
});
return;
}
if (currentVersion === APPROVAL_POLICY_SCHEMA_VERSION) {
tx(() => {
seedSettings(db);
assertTaskLeasesV57(db);
assertApprovalPoliciesV58(db);
migrateSocialCompanyScopeV59(db);
migrateFilesystemTaskWorkspacesV60(db);
});
return;
}
if (currentVersion === TASK_LEASE_SCHEMA_VERSION) {
tx(() => {
seedSettings(db);
assertTaskLeasesV57(db);
migrateApprovalPoliciesV58(db);
migrateSocialCompanyScopeV59(db);
migrateFilesystemTaskWorkspacesV60(db);
});
return;
}
if (currentVersion === BASELINE_SCHEMA_VERSION) {
tx(() => {
installBaselineSchema(db);
markBaselineSchema(db);
seedSettings(db);
assertBaselineSchema(db);
migrateTaskLeasesV57(db);
migrateApprovalPoliciesV58(db);
migrateSocialCompanyScopeV59(db);
migrateFilesystemTaskWorkspacesV60(db);
});
return;
}
if (profileHasApplicationTables(db)) {
const backupPath = createAutomaticBackup(`pre-migration-v${BASELINE_SCHEMA_VERSION}`);
log.info(`[schema] pre-migration snapshot for v${BASELINE_SCHEMA_VERSION} at ${backupPath}`);
withForeignKeysPaused(db, tx, () => {
upgradeLegacyProfileToBaselineV56({ db, readAll: ra });
seedSettings(db);
assertBaselineSchema(db);
migrateTaskLeasesV57(db);
migrateApprovalPoliciesV58(db);
migrateSocialCompanyScopeV59(db);
migrateFilesystemTaskWorkspacesV60(db);
});
return;
}
tx(() => {
installBaselineSchema(db);
markBaselineSchema(db);
seedSettings(db);
assertBaselineSchema(db);
migrateTaskLeasesV57(db);
migrateApprovalPoliciesV58(db);
migrateSocialCompanyScopeV59(db);
migrateFilesystemTaskWorkspacesV60(db);
});
interface Migration {
version: number;
name: string;
sql: string;
}
export function seedSettings(db: DatabaseSync): void {
const getSetting = (key: string): string | null => {
const row = db.prepare("select value from settings where key = ?").get(key) as { value: string } | undefined;
return row?.value ?? null;
};
const setSetting = (key: string, value: string) => {
db.prepare("insert into settings (key, value) values (?, ?) on conflict(key) do update set value = excluded.value").run(key, value);
};
if (!getSetting("theme")) setSetting("theme", "system");
if (!getSetting("updates_enabled")) setSetting("updates_enabled", "false");
if (!getSetting("log_retention_days")) setSetting("log_retention_days", "90");
const MIGRATIONS: Migration[] = [
{ version: 1, name: "initial_enterprise_schema", sql: initialEnterpriseSchema },
{ version: 2, name: "collaboration_provider_policy_schema", sql: collaborationProviderPolicySchema },
{ version: 3, name: "onboarding_execution_schema", sql: onboardingExecutionSchema },
{ version: 4, name: "files_pinned_and_scheduled_posts", sql: filesPinnedAndScheduledPosts },
{ version: 5, name: "chat_read_state", sql: chatReadState },
{ version: 6, name: "app_state", sql: appStateSchema },
{ version: 7, name: "skill_hardening", sql: skillHardeningSchema },
{ version: 8, name: "provider_health", sql: providerHealthSchema },
{ version: 9, name: "social_governance", sql: socialGovernanceSchema },
{ version: 10, name: "file_handoff_security", sql: fileHandoffSecuritySchema },
{ version: 11, name: "board_interventions", sql: boardInterventionSchema },
{ version: 12, name: "compliance_controls", sql: complianceControlsSchema },
{ version: 13, name: "search_documents", sql: searchDocumentsSchema },
{ version: 14, name: "provider_policy_usage", sql: providerPolicyUsageSchema },
{ version: 15, name: "identity_access", sql: identityAccessSchema },
{ version: 16, name: "org_governance", sql: orgGovernanceSchema },
{ version: 17, name: "operations_controls", sql: operationsControlsSchema },
{ version: 18, name: "sdlc_controls", sql: sdlcControlsSchema },
{ version: 19, name: "audit_replay", sql: auditReplaySchema },
{ version: 20, name: "rollback_snapshots", sql: rollbackSnapshotsSchema },
{ version: 21, name: "provider_auth_broker", sql: providerAuthBrokerSchema },
{ version: 22, name: "provider_rate_limit_observations", sql: providerRateLimitObservationSchema },
{ version: 23, name: "provider_request_runtime", sql: providerRequestRuntimeSchema },
{ version: 24, name: "task_run_provider_request", sql: taskRunProviderRequestSchema },
{ version: 25, name: "chat_message_delivery", sql: chatMessageDeliverySchema },
{ version: 26, name: "browser_platform_governance", sql: browserPlatformGovernanceSchema },
{ version: 27, name: "social_audit_records", sql: socialAuditRecordsSchema },
{ version: 28, name: "migration_cutover_journal", sql: migrationCutoverJournalSchema },
{ version: 29, name: "file_handoff_records", sql: fileHandoffRecordsSchema },
{ version: 30, name: "approval_source_refs", sql: approvalSourceRefsSchema },
{ version: 31, name: "provider_request_workspace", sql: providerRequestWorkspaceSchema },
{ version: 32, name: "browser_action_metadata", sql: browserActionMetadataSchema },
{ version: 33, name: "audit_event_immutability", sql: auditEventImmutabilitySchema },
{ version: 34, name: "provider_auth_sessions", sql: providerAuthSessionsSchema },
{ version: 35, name: "task_run_isolation", sql: taskRunIsolationSchema },
{ version: 36, name: "additional_connectors", sql: additionalConnectorsSchema },
{ version: 37, name: "custom_providers", sql: customProvidersSchema },
{ version: 38, name: "provider_auth_profile_cascade", sql: providerAuthProfileCascadeSchema },
{ version: 39, name: "audit_immutability_org_teardown", sql: auditImmutabilityOrgTeardownSchema },
{ version: 40, name: "documents_knowledge_automation", sql: documentsKnowledgeAutomationSchema },
{ version: 41, name: "task_subtasks_delete", sql: taskSubtasksDeleteSchema },
{ version: 42, name: "approval_notes_meetings_sprints", sql: approvalNotesMeetingsSprintsSchema },
{ version: 43, name: "composio_integration", sql: composioIntegrationSchema },
{ version: 44, name: "mention_wake_state", sql: mentionWakeStateSchema },
{ version: 45, name: "connector_grants", sql: connectorGrantsSchema },
];
const SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;
export function installSchema(db: DatabaseSync): void {
db.exec(`
create table if not exists schema_migrations (
version integer primary key,
name text not null,
applied_at text not null
);
`);
const row = db.prepare("select coalesce(max(version), 0) as version from schema_migrations").get() as { version: number };
let currentVersion = row.version;
if (currentVersion > SCHEMA_VERSION) {
throw new Error(`Database schema ${currentVersion} is newer than supported schema ${SCHEMA_VERSION}.`);
}
backfillMigrationLedger(db, currentVersion);
for (const migration of MIGRATIONS) {
if (currentVersion >= migration.version) continue;
applyMigration(db, migration);
currentVersion = migration.version;
}
}
function currentSchemaVersion(db: DatabaseSync): number {
const row = db
.prepare("select coalesce(max(version), 0) as version from schema_migrations")
.get() as { version: number } | undefined;
return row?.version ?? 0;
}
function profileHasApplicationTables(db: DatabaseSync): boolean {
const rows = db
.prepare("select name from sqlite_master where type = 'table' and name not like 'sqlite_%'")
.all() as Array<{ name: string }>;
return rows.some((row) => row.name !== "schema_migrations" && row.name !== "settings");
}
function withForeignKeysPaused<T>(db: DatabaseSync, tx: Transaction, op: () => T): T {
const row = db.prepare("pragma foreign_keys").get() as { foreign_keys: number } | undefined;
const previous = row?.foreign_keys === 1 ? "ON" : "OFF";
db.exec("pragma foreign_keys = OFF");
function applyMigration(db: DatabaseSync, migration: Migration): void {
db.exec("begin immediate");
try {
return tx(op);
} finally {
db.exec(`pragma foreign_keys = ${previous}`);
db.exec(migration.sql);
recordMigration(db, migration);
db.exec("commit");
} catch (error) {
db.exec("rollback");
throw error;
}
}
function backfillMigrationLedger(db: DatabaseSync, currentVersion: number): void {
for (const migration of MIGRATIONS) {
if (migration.version > currentVersion) return;
recordMigration(db, migration);
}
}
function recordMigration(db: DatabaseSync, migration: Migration): void {
db.prepare("insert or ignore into schema_migrations(version, name, applied_at) values (?, ?, datetime('now'))")
.run(migration.version, migration.name);
}