@agent-relay/factory 0.1.63 → 0.1.65

package/dist/cli/fleet.js

@@ -7,6 +7,7 @@ import { ensureCloudSession } from '@agent-relay/cloud';
 import { stringifyLogValue } from '../logging.js';
 import { resolveLocalFactoryConfig } from '../config/local-clone-paths.js';
 import { initializeFactory } from './init.js';
+import { diagnoseDeployedFactory, renderDeployedDiagnosis } from './diagnose.js';
 import { FACTORY_EXIT, exitCodeForDispatchResult, exitCodeForError, exitCodeForIterationReport, exitCodeForLoopReports, exitCodeForRelayDispatch, } from './exit-codes.js';
 import { FileStateStore, RelayfileCloudMountClient, checkFactoryLoopLiveness, closeProbePr, createFactory, createFleet, createFactoryCloudEventV1, ensureRelayBroker, FactoryCloudReporter, FileFactoryCloudEventOutbox, defaultGhRunner, explicitLinkedIssueKey, githubIssuePathParts, githubWatchStatePath, isAllowedFactoryGithubDraft, isAllowedFactoryGithubArtifactDraft, isInFactoryScope, parseGithubFactoryIssue, publishFactoryMountHealth, heldAgentsFromRegistry, parseOwnedBrokerAgentExitTimeoutMs, parseStandaloneBabysitTarget, readStandalonePullRequest, readLinearIssueWithCanonicalFallback, reapFactoryOrphansOnce, reapFactoryEnvironmentsOnce, readFactoryInFlightRegistry, readFactoryLoopHeartbeat, resolveFactoryStates, stateResolutionFromIds, standaloneBabysitterAgentName, renderAgentTask, resolveFactoryWorkspace, } from '../index.js';
 import { resolveTestGuidance } from '../dispatch/test-guidance.js';
@@ -17,6 +18,7 @@ import { loadOrCreateFactoryInstanceId, resolveFactoryInstanceName } from '../ob
 import { ensureFactoryIntegrations, inspectFactoryIntegration, openIntegrationUrl, } from '../mount/relayfile-integration-preflight.js';
 import { checkMountStaleness } from '../mount/relayfile-binary.js';
 import { MountAuthScopeError } from '../mount/mount-auth-error.js';
+import { createHostedCloudAccessTokenProvider, hostedCloudAccessTokenUrl, resolveHostedCloudApiUrl, } from '../mount/relayfile-cloud-mount-client.js';
 import { resolveRelayWorkspaceKey } from '../fleet/relay-workspace-key.js';
 import { isMeaningfullyBehind, readFactoryVersionInfo, } from '../version-info.js';
 import { GhCliIssuePublisher, NotionApiFactoryTasksClient, RelayChannelNotionClaimStore, RelayChannelNotionContractPublisher, generateFactoryTasksManifest, loadNotionIntakeManifest, runNotionIntake, } from '../intake/index.js';
@@ -39,7 +41,7 @@ export async function runFleetCli(argv, deps = {}) {
             return 0;
         }
         const { globals, args } = parseGlobalOptions(argv);
-        const command = parseFleetCommand(args);
+        const command = parseFleetCommand(args, deps.env ?? process.env);
         if (command.kind === 'featuremap-check') {
             const report = await (deps.featureMapCheck ?? checkFeatureMap)({
                 ...(command.manifestPath ? { manifestPath: command.manifestPath } : {}),
@@ -48,6 +50,26 @@ export async function runFleetCli(argv, deps = {}) {
             writeJson(out, report);
             return 0;
         }
+        if (command.kind === 'factory-diagnose') {
+            // Deliberately ahead of every config/mount/fleet setup below: the whole
+            // point of #295 is that this runs from anywhere — a laptop, a lane, a
+            // runbook — against an instance this checkout knows nothing about.
+            const diagnosis = await diagnoseDeployedFactory({
+                url: command.url,
+                ...(command.token ? { token: command.token } : {}),
+                ...(command.timeoutMs !== undefined ? { timeoutMs: command.timeoutMs } : {}),
+                ...(deps.diagnoseFetch ? { fetch: deps.diagnoseFetch } : {}),
+            });
+            if (command.json) {
+                writeJson(out, diagnosis);
+            }
+            else {
+                out.write(renderDeployedDiagnosis(diagnosis));
+            }
+            // Same contract as `factory canary`: a lane that only reads $? must be
+            // able to tell "production is dispatching" from "it is not".
+            return diagnosis.dispatching ? FACTORY_EXIT.OK : FACTORY_EXIT.FAILED;
+        }
         if (command.kind === 'factory-init') {
             await initializeFactory({ repo: command.repo, workspaceId: command.workspaceId, stdout: out, stderr: err });
             return 0;
@@ -395,13 +417,13 @@ export async function runFleetCli(argv, deps = {}) {
         }
     }
 }
-export function parseFleetCommand(args) {
+export function parseFleetCommand(args, env = process.env) {
     const [verb, ...rest] = args;
     if (!verb) {
         throw new Error(usage());
     }
     if (isFactoryAction(verb)) {
-        return parseFactoryCommand(args);
+        return parseFactoryCommand(args, env);
     }
     if (verb === 'fleet') {
         return parseFleetSubcommand(rest);
@@ -1056,7 +1078,7 @@ function resolveLocalMountFn(deps, mount) {
         throw new Error('Mount client does not provide Relayfile SDK local-mount support');
     };
 }
-function parseFactoryCommand(args) {
+function parseFactoryCommand(args, env = process.env) {
     const [action, issueOrPr, ...flags] = args;
     if (action === 'init') {
         const values = [issueOrPr, ...flags].filter((value) => Boolean(value));
@@ -1076,6 +1098,9 @@ function parseFactoryCommand(args) {
         }
         return { kind: 'factory-init', repo, workspaceId };
     }
+    if (action === 'diagnose') {
+        return parseFactoryDiagnoseFlags([issueOrPr, ...flags].filter((value) => Boolean(value)), env);
+    }
     if (action === 'start') {
         return { kind: 'factory', action, ...parseFactoryStartFlags([issueOrPr, ...flags]) };
     }
@@ -1159,6 +1184,61 @@ function evaluateFactoryCanary(report, issueArg) {
         reason: 'issue pulled but neither dispatched, triaged, nor skipped',
     };
 }
+function parseFactoryDiagnoseFlags(flags, env) {
+    let url;
+    // The injected environment, not the process one: an embedder or a hermetic
+    // test that supplies `deps.env` must not silently skip the authenticated
+    // read (#300 review, P2, cubic).
+    let token = env.FACTORY_EVIDENCE_TOKEN?.trim() || undefined;
+    let json = false;
+    let timeoutMs;
+    for (let index = 0; index < flags.length; index += 1) {
+        const flag = flags[index];
+        if (flag === '--deployed' || flag === '--url') {
+            url = requireValue(flags, ++index, flag);
+            continue;
+        }
+        if (flag === '--token') {
+            token = requireValue(flags, ++index, '--token');
+            continue;
+        }
+        if (flag === '--timeout-ms') {
+            const value = Number(requireValue(flags, ++index, '--timeout-ms'));
+            if (!Number.isInteger(value) || value <= 0)
+                throw new Error('--timeout-ms requires a positive integer');
+            timeoutMs = value;
+            continue;
+        }
+        if (flag === '--json') {
+            json = true;
+            continue;
+        }
+        // A bare URL is the same request spelled shorter.
+        if (!flag.startsWith('-') && !url) {
+            url = flag;
+            continue;
+        }
+        // Never echo the value: `factory diagnose <url> <token>` is a plausible
+        // slip, and this message reaches stderr and from there CI logs (#300
+        // review, CodeRabbit). The position is enough to find it.
+        if (!flag.startsWith('-')) {
+            throw new Error(`factory diagnose accepts one url; argument ${index + 1} is a second positional value. ` +
+                'Pass a token with --token, not as a bare argument.');
+        }
+        throw new Error(`Unknown factory diagnose option at argument ${index + 1}`);
+    }
+    if (!url) {
+        throw new Error('factory diagnose requires --deployed <url> (the deployed instance base URL)');
+    }
+    if (!/^https?:\/\//u.test(url)) {
+        // Not echoed, for the same reason as the positional case above: the value
+        // in the url slot is exactly where a mistyped `--token` argument lands
+        // (#300 review, cubic).
+        throw new Error('factory diagnose --deployed requires an http(s) url; the value given does not start with ' +
+            'http:// or https://. If that value is a token, pass it with --token.');
+    }
+    return { kind: 'factory-diagnose', url, json, ...(token ? { token } : {}), ...(timeoutMs !== undefined ? { timeoutMs } : {}) };
+}
 function parseFactoryStartFlags(args) {
     let mode = 'live';
     const flags = args.filter((arg) => Boolean(arg));
@@ -1208,10 +1288,18 @@ function factoryReportingMode(command) {
 async function buildFactoryCloudReporter(input) {
     if (!input.config.reporting.enabled)
         return undefined;
-    if (hasInjectedFactoryRuntime(input.deps) && !input.deps.cloudSessionProvider)
+    const runtimeEnv = input.deps.env ?? process.env;
+    // Hosted mode is a usable endpoint, not a defined-but-blank variable: an
+    // empty value must fall through to the local-session path instead of
+    // reaching createHostedCloudAccessTokenProvider, which throws on `new URL('')`.
+    const hostedAccessTokenUrl = hostedCloudAccessTokenUrl(runtimeEnv);
+    if (hasInjectedFactoryRuntime(input.deps)
+        && !input.deps.cloudSessionProvider
+        && !hostedAccessTokenUrl)
         return undefined;
     try {
-        const activeWorkspace = await (input.deps.resolveWorkspace ?? resolveFactoryWorkspace)();
+        const activeWorkspace = await (input.deps.resolveWorkspace
+            ?? (() => resolveFactoryWorkspace(undefined, runtimeEnv)))();
         const activeWorkspaceIds = new Set([
             activeWorkspace.workspaceId,
             activeWorkspace.cloudWorkspaceId,
@@ -1220,14 +1308,29 @@ async function buildFactoryCloudReporter(input) {
             input.logger.warn?.('[factory] Cloud progress reporting skipped because the active account workspace differs from Factory config');
             return undefined;
         }
-        const session = await (input.deps.cloudSessionProvider ?? ensureCloudSession)({ interactive: false });
         const outboxPath = input.config.reporting.outboxPath
             ?? join(dirname(input.config.loop.registryPath), 'factory-cloud-events.json');
         const instanceId = await loadOrCreateFactoryInstanceId(`${outboxPath}.instance-id`);
         const instanceName = resolveFactoryInstanceName(input.config);
-        const cloudFetch = async (_request, init) => session.client.fetch('/api/v1/factory/events', init);
+        let apiUrl;
+        let getAccessToken;
+        let cloudFetch;
+        if (hostedAccessTokenUrl) {
+            apiUrl = resolveHostedCloudApiUrl(runtimeEnv);
+            getAccessToken = createHostedCloudAccessTokenProvider({
+                url: hostedAccessTokenUrl,
+                fetchImpl: input.deps.cloudAccessTokenFetch ?? fetch,
+            });
+            cloudFetch = input.deps.cloudReporterFetch;
+        }
+        else {
+            const session = await (input.deps.cloudSessionProvider ?? ensureCloudSession)({ interactive: false });
+            apiUrl = session.auth.apiUrl;
+            getAccessToken = async () => session.client.snapshot().accessToken;
+            cloudFetch = async (_request, init) => session.client.fetch('/api/v1/factory/events', init);
+        }
         return new FactoryCloudReporter({
-            apiUrl: session.auth.apiUrl,
+            apiUrl,
             instance: {
                 id: instanceId,
                 bootId: randomUUID(),
@@ -1240,8 +1343,8 @@ async function buildFactoryCloudReporter(input) {
                 },
             },
             outbox: new FileFactoryCloudEventOutbox({ path: outboxPath }),
-            getAccessToken: async () => session.client.snapshot().accessToken,
-            fetch: cloudFetch,
+            getAccessToken,
+            ...(cloudFetch ? { fetch: cloudFetch } : {}),
             logger: input.logger,
             batchSize: input.config.reporting.batchSize,
             requestTimeoutMs: input.config.reporting.requestTimeoutMs,
@@ -1969,6 +2072,7 @@ function isCapability(value) {
 }
 function isFactoryAction(value) {
     return value === 'init' ||
+        value === 'diagnose' ||
         value === 'start' ||
         value === 'run-once' ||
         value === 'loop' ||
@@ -2040,6 +2144,9 @@ Commands:
   status                Print current factory status as JSON
   loop                  Run the bounded loop configured in factory.config.json
   loop-status           Print heartbeat/liveness status for the loop
+  diagnose --deployed <url>
+                        Ask a DEPLOYED instance why it is or is not dispatching
+                        (--token/FACTORY_EVIDENCE_TOKEN also reads /evidence)
   kill-loop             Send SIGTERM to the heartbeat pid
   reap-orphans [--include-held]
                         Report stale processes and held agents; opt in to release held agents past deadline