@method-ai-hq/sdk 0.18.0 → 0.18.2

package/README.md

@@ -3,7 +3,7 @@
 MIT-licensed JavaScript API and the `method` CLI. Source and releases: https://github.com/method-ai-hq/method-sdk
 
 ```sh
-npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.18.0/method-ai-hq-sdk-0.18.0.tgz
+npm install https://github.com/method-ai-hq/method-sdk/releases/download/v0.18.2/method-ai-hq-sdk-0.18.2.tgz
 npx method --version
 ```
 

package/dist/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@method-ai-hq/sdk",
-    "version": "0.18.0",
+    "version": "0.18.2",
     "description": "Build and run reusable .method files with checked steps and saved results.",
     "license": "MIT",
     "type": "module",

package/dist/packages/sdk/src/current-runtime.js

@@ -60,9 +60,6 @@ export async function runCurrentFile(file, flags, syncFactory, onEvent, client =
     const json = (path) => path ? JSON.parse(readFileSync(authoringPath(path), "utf8")) : undefined;
     if (flags.resume)
         assertCheckpointExecutor(json(join(flags['run-dir'], 'checkpoint.json')));
-    const setup = await localSetup(file, flags, baseConfig);
-    let config = setup.config;
-    const sourceRoot = setup.sourceRoot;
     const method = (await import('./authoring.js')).readDocument(file);
     const controller = new AbortController();
     const stop = () => controller.abort(Object.assign(new Error("Interrupted by operator"), { code: "interrupted" }));
@@ -79,8 +76,17 @@ export async function runCurrentFile(file, flags, syncFactory, onEvent, client =
         catch (error) {
             process.stderr.write(`Run records stay on this computer: ${error.message}\n`);
         }
-        // Records the start; sends nothing. The outbox starts when the run starts.
-        await sync?.start(method, json(flags.inputs) ?? {}, {}, false);
+        // Records the start; sends nothing. The outbox starts when the run starts. An inputs file that cannot be read fails
+        // the run below, with this record and no inputs.
+        let inputs = {};
+        try {
+            inputs = json(flags.inputs) ?? {};
+        }
+        catch { /* the run's setup failure */ }
+        await sync?.start(method, inputs, {}, false);
+        const setup = await localSetup(file, flags, baseConfig);
+        let config = setup.config;
+        const sourceRoot = setup.sourceRoot;
         // A run with its own OpenRouter key (config.classification.api_key_env) needs no Method sign-in for classification.
         const needs = accountNeeds(method, config);
         const classification = needs.classification ? managedClassification(client) : undefined;

package/dist/packages/sdk/src/local-cli.js

@@ -85,12 +85,12 @@ async function accountSync(path, flags) {
             return { client, outbox, version, sync: () => new Sync(client, runDir, state.workflow_id, state.version_id, state.id, readDocument(path).run_data === "device", outbox) };
         }
         const method = readDocument(path);
-        const setup = await localSetup(path, flags);
-        const needs = accountNeeds(method, setup.config);
-        if (needs.classification && !client.token())
+        // A setup that fails here fails the run too, and the run sends its failed record.
+        const needs = await localSetup(path, flags).then(setup => accountNeeds(method, setup.config), () => undefined);
+        if (needs?.classification && !client.token())
             await client.login();
         if (!client.token()) {
-            process.stderr.write(`Sign in to keep versions and runs in your account${needs.models ? " and to use hosted models" : ""}: method login\n`);
+            process.stderr.write(`Sign in to keep versions and runs in your account${needs?.models ? " and to use hosted models" : ""}: method login\n`);
             return undefined;
         }
         const version = await prepareVersion(client, outbox, path);

package/dist/packages/sdk/src/method-client.d.ts

@@ -22,6 +22,8 @@ export declare class MethodClient {
         onProgress?: (sent: number) => void;
         attempts?: number;
     }): Promise<Uint8Array>;
+    /** A lost connection: code network, and the message says which server. */
+    private unreachable;
     /** Send bytes in chunks and read the answer in chunks; a watchdog aborts when no bytes moved for stallMs. */
     private send;
     login(openBrowser?: (url: string) => void): Promise<void>;

package/dist/packages/sdk/src/method-client.js

@@ -75,7 +75,7 @@ export class MethodClient {
                     continue;
                 }
                 if (lost)
-                    throw Object.assign(Error(`Method cannot be reached at ${this.server} (${method} ${path}): ${error.cause?.code ?? error.message}. Check the connection and run again.`), { code: "network" });
+                    throw this.unreachable(method, path, error);
                 throw error;
             }
         }
@@ -109,11 +109,15 @@ export class MethodClient {
             }
             catch (error) {
                 if (attempt >= (options.attempts ?? 3) || error.retryable === false)
-                    throw error;
+                    throw error?.name === 'TypeError' ? this.unreachable(data ? 'PUT' : 'GET', path, error) : error;
                 await new Promise(resolve => setTimeout(resolve, 500 * 2 ** (attempt - 1)));
             }
         }
     }
+    /** A lost connection: code network, and the message says which server. */
+    unreachable(method, path, error) {
+        return Object.assign(Error(`Method cannot be reached at ${this.server} (${method} ${path}): ${error.cause?.code ?? error.message}. Check the connection and run again.`), { code: "network" });
+    }
     /** Send bytes in chunks and read the answer in chunks; a watchdog aborts when no bytes moved for stallMs. */
     async send(path, method, options) {
         const stallMs = options.stallMs ?? 15_000, controller = new AbortController();

package/dist/packages/sdk/src/method.js

@@ -4,7 +4,7 @@ import runtimeInfo from '@withmethod/runtime/package.json' with { type: 'json' }
 import { startRunWorker, waitForRun, cancelRun, workerAlive } from './run-worker.js';
 import { methodCache } from './prepare.js';
 import { restorePackage } from './method-files.js';
-import { publish } from './versions.js';
+import { publish, methodContent } from './versions.js';
 import { runSaved } from './run-saved.js';
 import { bindInput, bindConnection } from './bindings.js';
 import { existsSync, readFileSync, realpathSync } from "node:fs";
@@ -24,6 +24,18 @@ import { methodHelp, overviewHelp as help } from "./method-help.js";
 function safePath(path) {
     return authoringPath(path);
 }
+/** A run target that can save a version: a saved Method (ID or link), or a Method file that loads. */
+function loads(target) {
+    if (!target || !existsSync(target))
+        return true;
+    try {
+        loadWorkflow(methodContent(readDocument(target)));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function dispatchRunWorker(args, flags, extra = [], savedClient) {
     if (process.env.METHOD_RUN_WORKER === '1' || (!/[/\\]method\.(?:js|ts)$/.test(process.argv[1] ?? '') && !flags.background))
         return false;
@@ -44,8 +56,9 @@ async function dispatchRunWorker(args, flags, extra = [], savedClient) {
         const resolved = await withInputsFrom(flags, directory, /\.method$/i.test(args[1] ?? '') ? args[1] : undefined, client);
         workerArgs = [...withoutOptions(workerArgs, ['inputs-from', 'inputs']), '--inputs', resolved.inputs];
     }
-    // A new run of a signed-in computer is synced; a resumed run keeps the link that it has.
-    const server = !flags.resume && client?.token() ? client.server : undefined;
+    // A new run of a signed-in computer is synced; a resumed run keeps the link that it has. A Method file that does not
+    // load saves no version, so its run sends no record and gets no link.
+    const server = !flags.resume && client?.token() && loads(args[1]) ? client.server : undefined;
     await startRunWorker(workerArgs, directory, flags.background, server);
     return true;
 }

package/dist/packages/sdk/src/outbox.d.ts

@@ -56,7 +56,7 @@ export declare function lastSaved(server: string, methodId: string): {
 export declare function recordKnownVersion(server: string, methodId: string, versionId: string, versionNumber: number): void;
 /** A checkout of a saved version: the next save of this Method on this computer has it as its parent. */
 export declare function recordCheckout(server: string, methodId: string, versionId: string, versionNumber: number, workflow: unknown): void;
-/** Errors that a retry can fix: no response, a stalled transfer, a server error, or too many requests. */
+/** Errors that a retry can fix: no connection, a stalled transfer, a server error, or too many requests. */
 export declare function retryable(error: any): boolean;
 export declare class Outbox {
     readonly client: MethodClient;

package/dist/packages/sdk/src/outbox.js

@@ -40,12 +40,13 @@ function recordSaved(item, versionNumber) {
     writePrivateJson(savedFile(item.server), { ...savedVersions(item.server), [item.version_id]: { method_id: item.method_id, version_number: versionNumber } });
     writePrivateJson(methodFile(item.server, item.method_id), { version_id: item.version_id, version_number: versionNumber, workflow: item.body.workflow });
 }
-/** Errors that a retry can fix: no response, a stalled transfer, a server error, or too many requests. */
+/** Errors that a retry can fix: no connection, a stalled transfer, a server error, or too many requests. */
 export function retryable(error) {
     const status = error?.status ?? Number(/^(\d{3}):/.exec(String(error?.message))?.[1]);
-    return !status || status >= 500 || status === 429 || status === 408;
+    return status ? status >= 500 || status === 429 || status === 408 : unreachable(error) || error?.code === 'stalled';
 }
-const networkError = (error) => !(error?.status ?? /^\d{3}:/.test(String(error?.message))) && error?.code !== 'stalled';
+/** The server cannot be reached. An error on this computer (an unreadable run folder) is not one. */
+const unreachable = (error) => error?.code === 'network';
 export class Outbox {
     client;
     options;
@@ -221,7 +222,7 @@ export class Outbox {
                     }
                     // No response, a server error, or too many requests: after 3 in a row, stop and keep the items for a later
                     // command. A finished run never waits for a server that keeps failing.
-                    if (networkError(error) || status >= 500 || status === 429)
+                    if (unreachable(error) || status >= 500 || status === 429)
                         this.networkFailures++;
                     const attempt = (this.retryAt.get(key)?.attempt ?? 0) + 1;
                     this.retryAt.set(key, { at: Date.now() + Math.min(30_000, 500 * 2 ** (attempt - 1)), attempt });
@@ -256,7 +257,7 @@ export class Outbox {
         }
         catch (error) {
             const status = error?.status ?? Number(/^(\d{3}):/.exec(String(error?.message))?.[1]);
-            if (networkError(error) || status >= 500 || status === 429)
+            if (unreachable(error) || status >= 500 || status === 429)
                 this.networkFailures++;
         }
     }

package/dist/packages/sdk/src/run-saved.js

@@ -48,10 +48,17 @@ export async function runSaved(saved, flags, client) {
             return completed;
         }
     }
-    flags = await withInputsFrom(flags, directory, undefined, client);
     const inputFile = join(directory, 'requested-inputs.json');
-    const inputs = flags.inputs ? JSON.parse(readFileSync(resolve(flags.inputs), 'utf8')) : existsSync(inputFile) ? JSON.parse(readFileSync(inputFile, 'utf8')) : {};
-    writePrivateJson(inputFile, inputs);
+    // The start line already linked to this run: inputs that cannot be read fail it below, after its start is recorded.
+    let inputs = {}, unreadable;
+    try {
+        flags = await withInputsFrom(flags, directory, undefined, client);
+        inputs = flags.inputs ? JSON.parse(readFileSync(resolve(flags.inputs), 'utf8')) : existsSync(inputFile) ? JSON.parse(readFileSync(inputFile, 'utf8')) : {};
+        writePrivateJson(inputFile, inputs);
+    }
+    catch (error) {
+        unreadable = error;
+    }
     const setupFile = join(directory, 'setup.json');
     const setupEvents = existsSync(setupFile) ? JSON.parse(readFileSync(setupFile, 'utf8')) : [];
     setupEvents.push({ at: new Date().toISOString(), type: 'setup_started' });
@@ -61,6 +68,8 @@ export async function runSaved(saved, flags, client) {
     let acquired = false, started = false, revision = 0;
     const statePath = `/api/cli/methods/${encodeURIComponent(saved.workflow_id)}/state`;
     try {
+        if (unreadable)
+            throw unreadable;
         const resuming = !!flags.resume && existsSync(join(directory, 'checkpoint.json'));
         if (resuming)
             assertCheckpointExecutor(JSON.parse(readFileSync(join(directory, 'checkpoint.json'), 'utf8')));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@method-ai-hq/sdk",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "Build and run reusable .method files with checked steps and saved results.",
   "license": "MIT",
   "type": "module",