@dharma-ai-labs/agent-fabric 0.2.117 → 0.2.119

package/dist/index.js

@@ -17,7 +17,8 @@ import { contentHash, getActiveSkillBundleAuthorization, getExpiredSkillBundleAu
 import { executeTask, FileActionExecutionJournal, FileTaskReceiptStore, providerInstructionsForTask, } from '@dharma-ai-labs/agent-fabric-task-runner';
 import { CLI_USAGE } from './usage.js';
 import { superviseRelay } from './relaySupervisor.js';
-import { disableRelayAutostart, enableRelayAutostart, relayAutostartStatus, startRelayAutostart } from './relayAutostart.js';
+import { disableRelayAutostart, enableRelayAutostart, inspectOwnedRelayAutostart, relayAutostartStatus, startRelayAutostart, stopRelayAutostart } from './relayAutostart.js';
+import { relayRuntimeObservationReady, upgradeRelayRuntime } from './relayRuntimeUpgrade.js';
 import { assertStudyExactPoll, studyTaskIdFromFlags } from './studyExactTaskSelector.js';
 import { initializeRepositoryKnowledge, readRepositoryKnowledgeSource } from './repositoryKnowledge.js';
 import { inventoryRepositoryPackage, readRepositoryPackageSnapshot, readRepositorySourceBaselineSnapshot, writeRepositoryPackageSnapshot } from './repositoryPackage.js';
@@ -55,7 +56,7 @@ import { openCodexAppServerTransport } from '@dharma-ai-labs/agent-fabric-provid
 import { createNamedSessionTrust, isNamedSessionOwnerReceipt, renewNamedSessionLifetime } from './namedSessionTrust.js';
 import { startNamedCodexThread } from './namedCodexThread.js';
 export { openCooperativeInboxSession } from './cooperativeInboxSession.js';
-const VERSION = '0.2.117';
+const VERSION = '0.2.119';
 const USAGE = CLI_USAGE;
 const execFileAsync = promisify(execFile);
 const LOCAL_PROVIDER_IDS = ['codex', 'claude', 'agy', 'hermes'];
@@ -1525,6 +1526,103 @@ async function installStableRepositoryLauncher(workspace) {
     await writeFile(cmdPath, contents.windows, { mode: 0o600 });
     return { shell: '.dharma/bin/dharma', windows: '.dharma/bin/dharma.cmd' };
 }
+async function relayUpgrade(flags) {
+    const config = await readDeviceConfig();
+    if (!config)
+        throw new Error('relay_upgrade_enrollment_required');
+    if (flags.has('dry-run') && flags.has('apply'))
+        throw new Error('relay_upgrade_flags_conflict');
+    const workspace = await realpath(String(flags.get('workspace') || '.'));
+    const selected = selectDeviceWorkspace(await registry(), {
+        organizationId: config.organizationId, deviceId: config.deviceId, path: workspace,
+    });
+    if (!selected)
+        throw new Error('relay_upgrade_workspace_unregistered');
+    const home = dharmaHome();
+    const startup = await inspectOwnedRelayAutostart({ home });
+    const expectedLauncher = resolve(workspace, '.dharma', 'bin', process.platform === 'win32' ? 'dharma.cmd' : 'dharma');
+    if (startup.workspace !== workspace || startup.launcher !== expectedLauncher
+        || startup.policy !== resolve(workspace, '.dharma', 'approved-policy.json')) {
+        throw new Error('relay_upgrade_workspace_conflict');
+    }
+    const assertStopped = async () => {
+        if (await relaySupervisorProcessState(home) !== 'stopped' || await relayProcessState(home) !== 'stopped') {
+            throw new Error('relay_upgrade_runtime_busy: finish current work, then stop the owned relay before upgrading.');
+        }
+        const entries = await readdir(resolve(home, 'sessions'), { withFileTypes: true }).catch(error => {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !/^[a-z][a-z0-9-]{0,47}$/.test(entry.name))
+                continue;
+            if (await pidProcessState(resolve(home, 'sessions', entry.name, 'service.lock')) !== 'stopped') {
+                throw new Error('relay_upgrade_session_busy: finish and stop the named session before upgrading.');
+            }
+        }
+    };
+    return withRelayStartupMutation(async () => {
+        const receipt = await upgradeRelayRuntime({ home, workspace, version: VERSION,
+            organizationId: config.organizationId, deviceId: config.deviceId, workspaceId: selected.workspaceId,
+            dryRun: !flags.has('apply'), rollback: flags.has('rollback') }, {
+            assertStopped, inspectStartup: async () => {
+                const current = await inspectOwnedRelayAutostart({ home });
+                if (current.launcher !== expectedLauncher || current.policy !== startup.policy
+                    || current.workspace !== workspace)
+                    throw new Error('relay_upgrade_workspace_conflict');
+                return current;
+            },
+            launcherContents: version => stableRepositoryLauncherContents(version, { platform: process.platform, nodeDirectory: dirname(process.execPath) }),
+            legacyLauncherContents: version => stableRepositoryLauncherContents(version),
+            configureStartup: version => enableRelayAutostart({ home, workspace,
+                launcher: startup.launcher, policy: startup.policy, version }),
+            start: () => startRelayAutostart({ home }),
+            stop: async () => {
+                const activationLocks = resolve(home, 'registry', 'skill-activation-locks');
+                const locks = await readdir(activationLocks).catch(error => {
+                    if (error.code === 'ENOENT')
+                        return [];
+                    throw error;
+                });
+                for (const lock of locks) {
+                    if (lock.endsWith('.lock') && await pidProcessState(resolve(activationLocks, lock)) !== 'stopped') {
+                        throw new Error('relay_upgrade_work_in_progress: recovery must wait for a safe task boundary.');
+                    }
+                }
+                const binding = await readFile(resolve(home, 'relay', 'supervisor-workspace.json'), 'utf8')
+                    .then(value => JSON.parse(value)).catch(() => null);
+                if (await relaySupervisorProcessState(home) !== 'stopped'
+                    && binding?.workspaceId !== selected.workspaceId)
+                    throw new Error('relay_upgrade_process_unverified');
+                await stopRelayAutostart({ home });
+                const stopped = await relayStop();
+                if (stopped.ok !== true)
+                    throw new Error('relay_upgrade_stop_unconfirmed');
+            },
+            verify: async (version, since) => {
+                for (let attempt = 0; attempt < 90; attempt++) {
+                    const read = (name) => readFile(resolve(home, 'relay', name), 'utf8').catch(() => 'null');
+                    const supervisorPid = Number((await read('supervisor.pid')).trim());
+                    const relayPid = Number((await read('relay.pid')).trim());
+                    const supervisor = JSON.parse(await read('supervisor-workspace.json'));
+                    const lastPoll = JSON.parse(await read('last-successful-poll.json'));
+                    if (await relaySupervisorProcessState(home) === 'running' && await relayProcessState(home) === 'running'
+                        && relayRuntimeObservationReady({ version, workspaceId: selected.workspaceId, since,
+                            supervisorPid, relayPid, supervisor, lastPoll, allowLegacyPoll: version !== VERSION }))
+                        return;
+                    if (attempt < 89)
+                        await new Promise(resolveWait => setTimeout(resolveWait, 1000));
+                }
+                throw new Error('relay_upgrade_receiver_unconfirmed');
+            },
+        });
+        const validation = await validateContract(resolve(fileURLToPath(new URL('.', import.meta.url)), 'schemas'), 'https://schemas.dharma-ai.io/local-relay-upgrade/v1', receipt);
+        if (!validation.ok)
+            throw new Error('relay_upgrade_receipt_invalid');
+        return receipt;
+    });
+}
 export async function waitForRelayReadiness(options = {}) {
     const processState = options.processState || relayProcessState;
     const probe = options.probe || probeRelayConnection;
@@ -1969,6 +2067,33 @@ async function bootstrap(flags) {
         });
         scopes = redeemed.organizationApiTokenScopes;
     }
+    let organizationApiTokenStored = false;
+    let credentialFailure = null;
+    try {
+        organizationApiTokenStored = Boolean(await loadOrganizationApiToken({
+            hqUrl, organizationId, installationId: config.installationId,
+        }));
+        if (!organizationApiTokenStored && !String(process.env.DHARMA_ORG_API_TOKEN || '').trim()) {
+            credentialFailure = 'organization_api_credentials_required';
+        }
+    }
+    catch {
+        // Secure-store diagnostics can contain secrets. Emit only the failed stage.
+        credentialFailure = 'organization_api_credential_store_unavailable';
+    }
+    if (credentialFailure) {
+        return {
+            ok: false,
+            stage: 'organization_api_credentials',
+            code: credentialFailure,
+            message: 'The enrolled device is preserved, but its organization API credential is unavailable. Contact Dharma support for device-bound credential recovery; do not repeat enrollment or use another member\'s token.',
+            sharedRepositoryReady: false,
+            enrollment: {
+                organizationId, deviceId: config.deviceId, status: 'approved', organizationApiTokenStored,
+                scopes, recipientApproval, rebind,
+            },
+        };
+    }
     const onboardFlags = new Map(flags);
     onboardFlags.delete('grant');
     onboardFlags.set('portal-url', hqUrl);
@@ -1987,7 +2112,7 @@ async function bootstrap(flags) {
                 organizationId,
                 deviceId: config.deviceId,
                 status: 'approved',
-                organizationApiTokenStored: true,
+                organizationApiTokenStored,
                 scopes,
                 recipientApproval,
                 rebind,
@@ -2015,7 +2140,7 @@ async function bootstrap(flags) {
                 organizationId,
                 deviceId: config.deviceId,
                 status: 'approved',
-                organizationApiTokenStored: true,
+                organizationApiTokenStored,
                 scopes,
                 recipientApproval,
                 rebind,
@@ -2106,7 +2231,7 @@ async function bootstrap(flags) {
             organizationId,
             deviceId: config.deviceId,
             status: 'approved',
-            organizationApiTokenStored: true,
+            organizationApiTokenStored,
             scopes,
             recipientApproval,
             rebind,
@@ -2791,8 +2916,18 @@ async function evidencePreview(flags) {
                 captureProvenance: captureProvenance(session.endedAt),
             });
         });
+        const disclosureFailures = capsules.map((capsule) => {
+            try {
+                return containsDisallowedLocalPath(capsule) ? 'local_path_disclosure_forbidden' : null;
+            }
+            catch {
+                return 'local_path_inspection_depth_exceeded';
+            }
+        }).filter((reason) => reason !== null);
         automaticDisclosure = {
-            ready: true,
+            ready: disclosureFailures.length === 0,
+            blockedCapsuleCount: disclosureFailures.length,
+            reasonCodes: [...new Set(disclosureFailures)].sort(),
             disclosureClass: 'automatic_capsule',
             disclosureMode: capsules[0]?.automaticDisclosureMode ?? policy.evidence.automaticDisclosure?.mode ?? 'local_analysis',
             consentReceiptId: policy.evidence.automaticDisclosure?.consentReceiptId ?? null,
@@ -3481,13 +3616,14 @@ async function syncWorkspacePolicy(fabric, item, policyRevision, apply = true, p
         repositoryAgentId: item.repositoryAgentId,
         policyRevision, providers,
     });
+    const canonical = reconcileWorkspaceRegistration(await registry(), item, response);
     const generated = await materializeWorkspacePolicy({
-        workspace: item.path,
-        organizationId: item.organizationId,
+        workspace: canonical.path,
+        organizationId: canonical.organizationId,
         revision: String(response.workspace?.policyRevision || policyRevision),
         serverPolicyAuthorization: response.organizationPolicyAuthorization,
         serverPublicKeyEd25519: (await readDeviceConfig())?.serverPublicKeyEd25519,
-        workspaceId: item.workspaceId,
+        workspaceId: canonical.workspaceId,
         dryRun: !apply,
     });
     return {
@@ -3500,12 +3636,43 @@ async function syncWorkspacePolicy(fabric, item, policyRevision, apply = true, p
         },
     };
 }
+function reconcileWorkspaceRegistration(records, requested, response) {
+    const workspace = response.workspace && typeof response.workspace === 'object' && !Array.isArray(response.workspace)
+        ? response.workspace : null;
+    if (response.ok !== true || response.organizationId !== requested.organizationId
+        || !workspace || typeof workspace.id !== 'string' || !UUID_PATTERN.test(workspace.id)
+        || workspace.status !== 'active') {
+        throw new Error('fabric_workspace_registration_scope_mismatch');
+    }
+    if (workspace.id === requested.workspaceId)
+        return requested;
+    // The authenticated server upsert preserves the original ID for this device's
+    // route. Local records are hints only; signed policy verification still follows.
+    const candidates = records.filter(record => record.workspaceId === workspace.id);
+    if (candidates.length > 1)
+        throw new Error('fabric_workspace_registration_ambiguous');
+    const canonical = candidates[0];
+    if (canonical) {
+        if (canonical.organizationId !== requested.organizationId || canonical.path !== requested.path
+            || canonical.routeHash !== requested.routeHash || canonical.status !== 'active'
+            || canonical.repositoryRemoteHash !== requested.repositoryRemoteHash) {
+            throw new Error('fabric_workspace_registration_scope_mismatch');
+        }
+        return canonical;
+    }
+    // A restored credential store may lack the old registry row. Do not carry
+    // workspace-specific endpoint/package state into the server-returned identity.
+    return { ...requested, workspaceId: workspace.id, repositoryAgentId: null,
+        repositoryBindingId: null, endpointId: null, repositoryPackage: undefined,
+        repositoryRole: null, repositoryAgentKey: null, controlBranch: null };
+}
 async function registerWorkspaceBeforeRepositoryBind(fabric, item, policyRevision, providerIds = null) {
     // Repository connect is fenced by a server-side workspace, provider capability,
     // and signed device-session record. Register those facts before requesting the
     // permanent repository binding and control branch.
     const synchronized = await syncWorkspacePolicy(fabric, item, policyRevision, true, providerIds);
-    const registered = await bindRepositoryAgent(fabric, item);
+    const canonical = reconcileWorkspaceRegistration(await registry(), item, synchronized);
+    const registered = await bindRepositoryAgent(fabric, canonical);
     return { registered, synchronized };
 }
 async function readDeviceConfig() {
@@ -6101,7 +6268,7 @@ async function relayStart(flags) {
                 const result = await executeOneTask(fabric, leaseSeconds);
                 if (Date.now() - lastPollReceiptAt >= 30_000) {
                     await writeJsonAtomic(resolve(dharmaHome(), 'relay', 'last-successful-poll.json'), {
-                        at: new Date().toISOString(), workspaceId: canonicalWorkspace.workspaceId, version: VERSION,
+                        at: new Date().toISOString(), workspaceId: canonicalWorkspace.workspaceId, version: VERSION, pid: process.pid,
                     });
                     lastPollReceiptAt = Date.now();
                 }
@@ -6490,6 +6657,8 @@ export async function run(argv) {
         return probeRelayConnection();
     if (command === 'relay' && subcommand === 'stop')
         return relayStop();
+    if (command === 'relay' && subcommand === 'upgrade')
+        return relayUpgrade(flags);
     if (command === 'relay' && subcommand === 'autostart') {
         if (positional[2] === 'status')
             return relayAutostartStatus({ home: dharmaHome() });