@shardflux/cli 0.28.1 → 0.28.3

package/dist/orchestrator-commands.js

@@ -6,6 +6,9 @@
  * a session) reaches the orchestrator of the member who created that key (person-scope.ts). Text output is one line
  * per input, tab-separated, id first; --json prints the API's objects.
  */
+import { mkdtemp, open, unlink, rmdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, basename } from 'node:path';
 import { inputSettled } from '@shardflux/sdk';
 import { parseDuration } from "./args.js";
 import { out, str } from "./commands.js";
@@ -13,6 +16,7 @@ import { EXIT, UsageError } from "./errors.js";
 import { humanBytes } from "./files-mirror.js";
 import { inScope } from "./person-scope.js";
 import { progress } from "./progress.js";
+import { deviceOutcomeLines } from "./device-outcomes.js";
 /** --wait's default: how long `say --wait` follows an input before it stops (the input goes on). */
 export const SAY_WAIT_MS = 10 * 60_000;
 const oneLine = (s, max) => {
@@ -198,17 +202,54 @@ const idOf = (id) => {
     return id;
 };
 export const ORCHESTRATOR_HANDLERS = {
+    async 'orchestrator show'(ctx, values, [id]) {
+        const detail = await inScope(ctx, values, (client, scope) => client.orchestrator.input(idOf(id), { ...orgOnly(scope), signal: ctx.signal }));
+        out(ctx, [`${detail.input.id}\t${stateLabel(detail.input)}`, resultText(detail.input), ...deviceOutcomeLines(detail.device_requests)].filter(Boolean).join('\n') + '\n', detail);
+        return EXIT.ok;
+    },
     async 'orchestrator say'(ctx, values, words) {
         const text = words.join(' ');
-        if (!text.trim())
-            throw new UsageError('missing <words...> for "shard orchestrator say"');
+        const paths = Array.isArray(values.file) ? values.file : typeof values.file === 'string' ? [values.file] : [];
+        if (!text.trim() && !paths.length)
+            throw new UsageError('missing <words> for "shard orchestrator say"');
         const selection = selectionOf(values);
         const wait = values.wait === true;
         const timeoutMs = str(values.timeout) === undefined ? SAY_WAIT_MS : parseDuration(str(values.timeout), 'timeout');
         if (!wait && str(values.timeout) !== undefined)
             throw new UsageError('--timeout goes with --wait.');
         return inScope(ctx, values, async (client, scope) => {
-            const input = await client.orchestrator.say(text, { ...orgOnly(scope), ...(selection ? { selection } : {}), signal: ctx.signal });
+            let spool;
+            let input;
+            const files = [];
+            try {
+                for (const path of paths) {
+                    if (path !== '-') {
+                        files.push({ path, name: basename(path) });
+                        continue;
+                    }
+                    if (!spool) {
+                        spool = await mkdtemp(join(ctx.io.env.HOME ?? tmpdir(), 'shard-input-'));
+                        const sink = await open(join(spool, 'stdin'), 'wx', 0o600);
+                        try {
+                            for await (const chunk of ctx.io.stdin) {
+                                ctx.signal.throwIfAborted();
+                                await sink.writeFile(chunk);
+                            }
+                        }
+                        finally {
+                            await sink.close();
+                        }
+                    }
+                    files.push({ path: join(spool, 'stdin'), name: str(values['file-name']) ?? 'stdin' });
+                }
+                input = await client.orchestrator.say({ text, files, ...orgOnly(scope), ...(selection ? { selection } : {}), signal: ctx.signal });
+            }
+            finally {
+                if (spool) {
+                    await unlink(join(spool, 'stdin')).catch(() => undefined);
+                    await rmdir(spool);
+                }
+            }
             if (!wait) {
                 out(ctx, `${input.id}\t${stateLabel(input)}\n`, { input });
                 return EXIT.ok;

package/dist/task-auto-land.d.ts

@@ -0,0 +1,22 @@
+import type { NeedsYouItem } from '@shardflux/sdk';
+import type { Ctx } from './commands.js';
+import type { LandDeps } from './land.js';
+interface TaskAutoLandOptions {
+    needs(signal: AbortSignal): Promise<NeedsYouItem[]>;
+    land: LandDeps;
+    enabled(project: string): boolean;
+    log(line: string): void;
+    now?: () => number;
+    stateDir?: string;
+}
+export declare class TaskAutoLand {
+    #private;
+    readonly options: TaskAutoLandOptions;
+    constructor(options: TaskAutoLandOptions);
+    /** One serial pass. A conflict waits for a new result; a disconnected/busy folder or failed receipt retries. */
+    tick(signal: AbortSignal): Promise<void>;
+}
+/** Only projects actually linked on this computer; a task's repository is checked again before any VM is opened. */
+export declare function taskLandProjects(ctx: Ctx): string[];
+export declare function runTaskAutoLand(ctx: Ctx): Promise<void>;
+export {};

package/dist/task-auto-land.js

@@ -0,0 +1,162 @@
+/** Finished board tasks reach their linked folders even with the desktop board closed (next CLI release). */
+import { setTimeout as delay } from 'node:timers/promises';
+import { conversationClient } from "./conversation-commands.js";
+import { localConversations } from "./conversations.js";
+import { landDeps, landTask } from "./land.js";
+import { selectedProjects } from "./project-preparation.js";
+import { TwinLedger } from "./worktree-twin.js";
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { writePrivateFile } from "./credentials.js";
+export class TaskAutoLand {
+    #attempts = new Map();
+    options;
+    constructor(options) {
+        this.options = options;
+        if (options.stateDir) {
+            try {
+                const rows = JSON.parse(readFileSync(join(options.stateDir, 'task-auto-land.json'), 'utf8'));
+                for (const [id, row] of Object.entries(rows))
+                    if (typeof row.key === 'string' && Number.isSafeInteger(row.tries)
+                        && Number.isFinite(row.retryAt) && typeof row.blocked === 'boolean')
+                        this.#attempts.set(id, row);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+    }
+    #save() {
+        if (this.options.stateDir)
+            writePrivateFile(this.options.stateDir, join(this.options.stateDir, 'task-auto-land.json'), JSON.stringify(Object.fromEntries(this.#attempts)) + '\n');
+    }
+    /** One serial pass. A conflict waits for a new result; a disconnected/busy folder or failed receipt retries. */
+    async tick(signal) {
+        const now = this.options.now ?? Date.now, needs = await this.options.needs(signal);
+        // Keep the result key through disconnects and service restarts. A missing discovery page is not permission to
+        // repeat a conflict's steer or an already recorded landing. A master's next done report has a new key.
+        for (const item of needs) {
+            if (signal.aborted)
+                return;
+            if (item.kind !== 'land' || !item.task_id || !item.project_id || !this.options.enabled(item.project_id))
+                continue;
+            const key = `${item.id}@${item.since}`, prior = this.#attempts.get(item.id);
+            if (prior?.key === key && (prior.blocked || prior.retryAt > now()))
+                continue;
+            try {
+                const result = await landTask({ ...this.options.land, signal }, item.task_id, { automatic: true });
+                if (!result.recorded)
+                    throw new Error(result.record_error ?? 'The task landing receipt was not recorded.');
+                this.#attempts.set(item.id, { key, tries: 0, retryAt: 0, blocked: true });
+                this.#save();
+                this.options.log(result.message);
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                const code = error.code;
+                const tries = prior?.key === key ? prior.tries + 1 : 1;
+                const blocked = code === 'land_conflict' || code === 'land_unrelated' || code === 'land_result_unready';
+                this.#attempts.set(item.id, { key, tries, blocked, retryAt: now() + Math.min(600_000, 1000 * 2 ** Math.min(tries, 9)) });
+                this.#save();
+                // Off and a folder on another computer need no warning. The existing one-per-task land item stays intact.
+                if (code !== 'land_automatic_off' && code !== 'land_device_unlinked')
+                    this.options.log(`Task ${item.task_id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+}
+/** Only projects actually linked on this computer; a task's repository is checked again before any VM is opened. */
+export function taskLandProjects(ctx) {
+    const profile = ctx.store.profile(ctx.apiUrl), fallback = profile.project_id ?? profile.api_key?.project_id;
+    return [...new Set([
+            ...selectedProjects(ctx).map(p => p.project_id ?? fallback),
+            ...Object.values(localConversations(ctx)).filter(c => !c.handed_off).map(c => c.project_id),
+        ].filter((p) => Boolean(p)))];
+}
+export async function runTaskAutoLand(ctx) {
+    if (ctx.signal.aborted)
+        return;
+    const client = conversationClient(ctx), ledger = new TwinLedger(ctx.store.dir);
+    const profile = ctx.store.profile(ctx.apiUrl);
+    const key = Boolean(ctx.io.env.SHARDFLUX_API_KEY?.trim()) || profile.api_key !== undefined;
+    const log = (line) => { ctx.io.stderr.write(line + '\n'); };
+    const needs = new Map();
+    const watches = new Map();
+    const engine = new TaskAutoLand({
+        land: landDeps(ctx), enabled: project => ledger.mode(project) === 'auto', log, stateDir: ctx.store.dir,
+        needs: () => Promise.resolve([...needs.values()].flat()),
+    });
+    let landing, again = false;
+    const kick = () => {
+        again = true;
+        if (!landing)
+            landing = (async () => {
+                while (again && !ctx.signal.aborted) {
+                    again = false;
+                    await engine.tick(ctx.signal);
+                }
+            })().catch(error => { if (!ctx.signal.aborted)
+                log(`Task landing: ${error instanceof Error ? error.message : String(error)}`); })
+                .finally(() => { landing = undefined; });
+        return landing;
+    };
+    const follow = async (projectId, signal) => {
+        let failures = 0;
+        while (!signal.aborted) {
+            try {
+                const organizationId = key ? undefined : (await ctx.account().projects.get(projectId)).organization_id;
+                const scope = { projectId, ...(organizationId ? { organizationId } : {}), signal };
+                // Read once (including results that finished while offline), then use the held feed. No repeated whole-board
+                // reads while idle, and a slow project's feed cannot delay another project's landing or device heartbeats.
+                const board = await client.board.get(scope);
+                needs.set(projectId, board.needs_you);
+                void kick();
+                failures = 0;
+                for await (const update of client.board.watch({ ...scope, cursor: board.cursor })) {
+                    if (update.reset)
+                        needs.set(projectId, update.board.needs_you);
+                    else if (update.needs_you !== null)
+                        needs.set(projectId, update.needs_you);
+                    void kick();
+                }
+                if (!signal.aborted)
+                    throw new Error('The board feed ended before its device helper stopped.');
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                log(`Task landing discovery: ${error instanceof Error ? error.message : String(error)}`);
+                await delay(Math.min(60_000, 1000 * 2 ** Math.min(failures++, 6)), undefined, { signal }).catch(() => undefined);
+            }
+        }
+    };
+    try {
+        while (!ctx.signal.aborted) {
+            const projects = new Set(taskLandProjects(ctx).filter(p => ledger.mode(p) === 'auto'));
+            for (const [project, watch] of watches)
+                if (!projects.has(project)) {
+                    watch.abort.abort();
+                    await watch.work;
+                    watches.delete(project);
+                    needs.delete(project);
+                }
+            for (const project of projects)
+                if (!watches.has(project)) {
+                    const abort = new AbortController(), signal = AbortSignal.any([ctx.signal, abort.signal]);
+                    const work = follow(project, signal);
+                    watches.set(project, { abort, work });
+                }
+            // The local setting and deferred folder/receipt retries do not wait for a remote board event.
+            await kick();
+            await delay(2000, undefined, { signal: ctx.signal }).catch(() => undefined);
+        }
+    }
+    finally {
+        for (const watch of watches.values())
+            watch.abort.abort();
+        await Promise.all([...watches.values()].map(w => w.work));
+        await landing;
+    }
+}

package/dist/task-land-hub.py

@@ -106,6 +106,12 @@ def land(a):
         have = {b: tip(work, 'refs/heads/' + b) for b in wanted}
         before = have.get(into)
         t, created = have.get(result), False
+        if a.get('require_result'):
+            if not t:
+                return {'state': 'unready', 'into': into, 'reason': 'result_missing'}
+            missing = [s for s in sources if not have.get(s) or not ancestor(work, have[s], t)]
+            if missing:
+                return {'state': 'unready', 'into': into, 'reason': 'workers_not_integrated', 'unintegrated': missing}
         if not t:
             # A master that did not merge its workers: merge them here, each only when it merges cleanly.
             for s in sources:

package/dist/vault.js

@@ -28,20 +28,15 @@ export function vaultOutput(vault, name, options = {}) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'ignore'], env: options.env, signal: options.signal });
         const chunks = [];
-        let size = 0;
         let failed = false;
         const timer = setTimeout(() => {
             failed = true;
             child.kill('SIGKILL');
         }, 30_000);
         child.stdout.on('data', (chunk) => {
-            size += chunk.length;
-            if (size > 65_538) {
-                failed = true;
-                child.kill('SIGKILL');
-            }
-            else
-                chunks.push(chunk);
+            // Provider JSON includes metadata as well as the selected value. Enforce the secret store's value limit
+            // after extraction; a transport cap here rejected valid small values in larger items.
+            chunks.push(chunk);
         });
         child.on('error', () => {
             clearTimeout(timer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/cli",
-  "version": "0.28.1",
+  "version": "0.28.3",
   "type": "module",
   "description": "shard: the Shardflux command line. Create an account, sign in, set up keys and billing, then open, run commands in, move files to, suspend, resume and fork serverless agent workspaces.",
   "license": "Apache-2.0",
@@ -53,7 +53,7 @@
     "snappyjs": "0.7.0",
     "ws": "8.22.0",
     "yaml": "2.9.1",
-    "@shardflux/sdk": "^0.30.1"
+    "@shardflux/sdk": "^0.30.3"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
@@ -65,10 +65,10 @@
     "typescript-eslint": "8.70.1"
   },
   "optionalDependencies": {
-    "@shardflux/desktop-darwin-arm64": "0.9.2",
-    "@shardflux/desktop-darwin-x64": "0.9.2",
-    "@shardflux/desktop-linux-arm64": "0.9.2",
-    "@shardflux/desktop-linux-x64": "0.9.2"
+    "@shardflux/desktop-darwin-arm64": "0.9.4",
+    "@shardflux/desktop-darwin-x64": "0.9.4",
+    "@shardflux/desktop-linux-arm64": "0.9.4",
+    "@shardflux/desktop-linux-x64": "0.9.4"
   },
   "scripts": {
     "build": "node scripts/build.mjs",