agents-relay 2.0.67 → 2.0.69

package/dist/cli-review.js

@@ -1,5 +1,5 @@
-import { storeFor, arg, hasArg, withEventBus, requestManagedReconciliation } from './cli-support.js';
-import { normalizeThreadId, resolveReviewerThreadDestination } from './reviewer-thread.js';
+import { arg, hasArg, relayControlCommand } from './cli-support.js';
+import { normalizeThreadId } from './reviewer-thread.js';
 export function reviewRequestThreadOverride(args) {
     const values = [...args];
     return hasArg(values, '--thread-id')
@@ -9,27 +9,10 @@ export function reviewRequestThreadOverride(args) {
 export async function runReviewCommand(action, reviewArgs) {
     if (action !== 'request')
         throw new Error('review supports: request');
-    if (!arg(reviewArgs, '--repo') || !arg(reviewArgs, '--pr') || !arg(reviewArgs, '--id'))
-        throw new Error('review request requires --repo, --pr and --id');
+    const jobId = arg(reviewArgs, '--id');
+    if (!arg(reviewArgs, '--repo') || !jobId)
+        throw new Error('review request requires --repo and --id');
     const threadId = reviewRequestThreadOverride(reviewArgs);
-    const { store, job, localFile } = await storeFor(reviewArgs);
-    if (localFile)
-        throw new Error('review request requires a managed GitHub Job');
-    if (job.state === 'CANCELLED' || job.state === 'COMPLETED')
-        throw new Error('Cannot request review for terminal Job');
-    if (!job.reviewEnabled)
-        throw new Error('Review disabled for this Job');
-    if (job.tasks.some(task => task.agentName === 'reviewer' && ['RUNNING', 'QUEUED', 'DRAFT'].includes(task.state)))
-        throw new Error('Review already queued or running; refusing duplicate request');
-    if (job.review?.outcome === 'approved')
-        throw new Error('Current head already approved; review request not needed');
-    if (threadId !== undefined) {
-        job.reviewerThreadId = threadId;
-        job.updatedAt = new Date().toISOString();
-        await store.saveJob(job);
-    }
-    const destination = resolveReviewerThreadDestination(job);
-    await withEventBus(reviewArgs, async (bus) => requestManagedReconciliation(bus, job));
-    console.log(JSON.stringify({ jobId: job.id, pr: job.prNumber, reviewerThreadId: destination?.threadId ?? null, status: 'requested', note: 'Relay graph will create the review Task once eligible; this is not a delivery receipt.' }, null, 2));
-    return;
+    const job = await relayControlCommand(reviewArgs, { command: 'review.request', jobId, ...(threadId !== undefined ? { threadId } : {}) });
+    console.log(JSON.stringify({ jobId: job.id, pr: job.externalPrNumber ?? job.prNumber ?? 0, reviewerThreadId: job.reviewerThreadId ?? null, status: 'requested', note: 'Relay graph will create the review Task once eligible; this is not a delivery receipt.' }, null, 2));
 }

package/dist/cli-support.js

@@ -1,6 +1,11 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { InMemoryStore, GitHubStore } from './store.js';
 import { githubAuthContext } from './github-auth.js';
+import { noGitHubMode } from './no-github.js';
+import { basename } from 'node:path';
+import { createJobIdRegistryResolver } from './local-job-registry.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { NatsEventBus, eventFor } from './events.js';
 import { parseJobSchedule } from './scheduler.js';
 import { parseJobTagJson } from './task-tag.js';
@@ -51,20 +56,33 @@ export async function textOption(args, inlineFlag, fileFlag) {
 export function integerArg(args, name, fallback) { if (!hasArg(args, name))
     return fallback; const value = Number(arg(args, name)); if (!Number.isInteger(value) || value < 0)
     throw new Error(`${name} must be a non-negative integer`); return value; }
-export function repository(args) { const value = arg(args, '--repo'); if (!value)
+export function repository(args) { const value = arg(args, '--repo'); if (!value && noGitHubMode(args))
+    return 'local/' + basename(process.cwd()); if (!value)
     throw new Error('--repo is required for GitHub-backed operation'); return value; }
 export function pullRequest(args) { const value = Number(arg(args, '--pr')); if (!Number.isInteger(value) || value <= 0)
     throw new Error('--pr is required for GitHub-backed operation'); return value; }
 async function localStore(file) { const parsed = JSON.parse(await readFile(file, 'utf8')); const store = new InMemoryStore(parsed); return { store, job: await store.load(parsed.id) }; }
 export async function githubStore(args) { const auth = await githubAuthContext(args); return new GitHubStore(auth.client, repository(args), pullRequest(args), auth.trustedAuthors); }
-export async function storeFor(args) { const repo = arg(args, '--repo'); const pr = arg(args, '--pr'); if (repo && pr) {
-    const store = await githubStore(args);
+export async function storeFor(args) {
+    const file = arg(args, '--file');
+    if (file) {
+        const loaded = await localStore(file);
+        return { ...loaded, localFile: file };
+    }
+    const repo = noGitHubMode(args) ? repository(args) : arg(args, '--repo');
     const jobId = arg(args, '--id');
-    if (!jobId)
-        throw new Error('--id is required for GitHub-backed operation');
-    return { store, job: await store.load(jobId), localFile: null };
-} const file = arg(args, '--file'); if (!file)
-    throw new Error('Local mode is demo/test only; pass --file explicitly'); const loaded = await localStore(file); return { store: loaded.store, job: loaded.job, localFile: file }; }
+    if (!repo || !jobId)
+        throw new Error('Local Job requires --repo and --id (or explicit --file)');
+    const directory = arg(args, '--store-dir') || join(homedir(), '.agents-relay', 'stores');
+    const binding = await createJobIdRegistryResolver(directory, new Map())(jobId);
+    if (!binding || binding.job.repository !== repo)
+        throw new Error('Immutable local Job not found for repository: ' + jobId);
+    const suppliedPr = arg(args, '--pr');
+    const boundPr = binding.job.externalPrNumber ?? (binding.job.prNumber > 0 ? binding.job.prNumber : 0);
+    if (suppliedPr && boundPr !== Number(suppliedPr))
+        throw new Error('Local Job external PR binding mismatch');
+    return { store: binding.store, job: await binding.store.load(jobId), localFile: null };
+}
 export async function saveLocal(file, job) { if (file)
     await writeFile(file, JSON.stringify(job, null, 2)); }
 export async function relayControlJob(args, jobId) {
@@ -90,6 +108,61 @@ export async function relayControlJob(args, jobId) {
         throw new Error(`Agents Relay job request failed: ${await response.text() || `HTTP ${response.status}`}`);
     return await response.json();
 }
+export async function relayControlCommand(args, body) {
+    const host = arg(args, '--host', '127.0.0.1');
+    const port = Number(arg(args, '--port', String(SERVICE_DEFAULTS.port)));
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        throw new Error('--port must be an integer between 1 and 65535');
+    let response;
+    try {
+        response = await fetch(`http://${host}:${port}/api/control`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) });
+    }
+    catch (error) {
+        throw new Error(`Agents Relay service unavailable at ${host}:${port}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok)
+        throw new Error(`Agents Relay control command failed: ${await response.text() || `HTTP ${response.status}`}`);
+    return await response.json();
+}
+export async function relayJobList(args) {
+    const host = arg(args, '--host', '127.0.0.1');
+    const port = Number(arg(args, '--port', String(SERVICE_DEFAULTS.port)));
+    const repo = arg(args, '--repo');
+    let response;
+    try {
+        response = await fetch(`http://${host}:${port}/api/jobs`);
+    }
+    catch (error) {
+        throw new Error(`Agents Relay service unavailable at ${host}:${port}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok)
+        throw new Error(`Agents Relay jobs request failed: ${await response.text() || `HTTP ${response.status}`}`);
+    const jobs = await response.json();
+    return repo ? jobs.filter(job => job.repository === repo) : jobs;
+}
+export async function relayJobStateCommand(args, jobId, state) {
+    const host = arg(args, '--host', '127.0.0.1');
+    const port = Number(arg(args, '--port', String(SERVICE_DEFAULTS.port)));
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        throw new Error('--port must be an integer between 1 and 65535');
+    const params = new URLSearchParams({ id: jobId, state });
+    const repo = arg(args, '--repo');
+    const pr = Number(arg(args, '--pr'));
+    if (repo)
+        params.set('repo', repo);
+    if (Number.isInteger(pr) && pr > 0)
+        params.set('pr', String(pr));
+    let response;
+    try {
+        response = await fetch(`http://${host}:${port}/api/job-state?${params.toString()}`, { method: 'POST' });
+    }
+    catch (error) {
+        throw new Error(`Agents Relay service unavailable at ${host}:${port}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok)
+        throw new Error(`Agents Relay job state command failed: ${await response.text() || `HTTP ${response.status}`}`);
+    return await response.json();
+}
 export async function relayTaskCommand(args, body) {
     const host = arg(args, '--host', '127.0.0.1');
     const port = Number(arg(args, '--port', String(SERVICE_DEFAULTS.port)));

package/dist/cli-worker-task.js

@@ -0,0 +1,63 @@
+import { taskOverallTimeoutMs } from './types.js';
+import { arg, hasArg, textOption, integerArg, chatGptTabClosePolicy, storySize, priority, continuation } from './cli-support.js';
+import { parseAgentGraph } from './agent-graph.js';
+import { createTaskEntity } from './workflow/entity-creation.js';
+export async function workerTaskFromArgs(job, args, now) {
+    const model = arg(args, '--model');
+    const adapterValue = arg(args, '--adapter');
+    const adapter = (adapterValue || 'codex');
+    const outputKind = arg(args, '--output');
+    const outputPath = arg(args, '--output-path');
+    const input = await textOption(args, '--input', '--input-file');
+    const agentGraph = hasArg(args, '--agent-graph') || hasArg(args, '--agent-graph-file') ? await textOption(args, '--agent-graph', '--agent-graph-file') : undefined;
+    if (agentGraph)
+        parseAgentGraph(agentGraph);
+    if (!input.trim())
+        throw new Error('task create requires --input-file PATH|- or --input MARKDOWN');
+    if (!['codex', 'chatgpt', 'orchestrator'].includes(adapter))
+        throw new Error('task create --adapter must be codex, chatgpt, or orchestrator');
+    if (outputKind !== 'task-pr' && outputKind !== 'file')
+        throw new Error('task create requires --output task-pr|file');
+    if (outputKind === 'file' && !outputPath)
+        throw new Error('--output file requires --output-path');
+    if (adapter !== 'orchestrator' && ['--provider', '--profile', '--reasoning', '--cwd', '--chatgpt-project'].some(flag => hasArg(args, flag)) && !model)
+        throw new Error('task create explicit routing requires --model');
+    const routing = adapter === 'orchestrator' || !model ? undefined : { provider: arg(args, '--provider', 'openai'), model, profile: arg(args, '--profile') || undefined, reasoning: arg(args, '--reasoning') || undefined, cwd: arg(args, '--cwd') || undefined, projectId: arg(args, '--chatgpt-project') || undefined, decidedBy: 'cli', decidedAt: now };
+    const workerRequirements = adapter === 'orchestrator' || routing ? undefined : { capabilities: [], runtime: adapterValue ? adapter : undefined };
+    const closePolicy = hasArg(args, '--chatgpt-tab-close-policy') ? chatGptTabClosePolicy(args) : undefined;
+    const size = storySize(args);
+    const dependencies = arg(args, '--deps').split(',').filter(Boolean);
+    const timeoutMs = adapter === 'orchestrator' ? 0 : hasArg(args, '--timeout') ? integerArg(args, '--timeout', taskOverallTimeoutMs(size, routing?.reasoning)) : routing ? taskOverallTimeoutMs(size, routing.reasoning) : 0;
+    return createTaskEntity(job, {
+        jobId: job.id,
+        id: arg(args, '--task-id', 'initial'),
+        priority: priority(args, job.priority ?? 'P2'),
+        storySize: size,
+        projectName: arg(args, '--project') || undefined,
+        agentName: arg(args, '--agent') || undefined,
+        agentGraph,
+        parentTaskId: arg(args, '--parent') || null,
+        dependencies,
+        capabilities: arg(args, '--capabilities').split(',').filter(Boolean),
+        workerRequirements,
+        adapter,
+        chatgptTabClosePolicy: closePolicy,
+        input: input || 'true',
+        attachments: arg(args, '--attachments').split(',').filter(Boolean),
+        output: outputKind === 'file' ? { kind: 'file', path: outputPath } : { kind: 'task_pr' },
+        routing,
+        continuation: continuation(args),
+        continuationDeliveredAt: null,
+        attempt: 0,
+        maxAttempts: Number(arg(args, '--max-attempts', '3')),
+        leaseOwner: null,
+        leaseExpiresAt: null,
+        executionId: null,
+        threadId: null,
+        result: null,
+        error: null,
+        timeoutMs,
+        createdAt: now,
+        updatedAt: now
+    }, { defer: hasArg(args, '--draft') });
+}