@method-ai-hq/sdk 0.0.0-stage → 0.14.2

package/dist/packages/sdk/src/browser-service.py

@@ -0,0 +1,127 @@
+"""Private line protocol for the pinned browser-use direct controls."""
+import asyncio
+import contextlib
+import json
+import os
+import sys
+import signal
+import shutil
+from pathlib import Path
+from urllib.parse import urlparse
+
+os.environ['ANONYMIZED_TELEMETRY'] = 'false'
+os.environ['BROWSER_USE_LOGGING_LEVEL'] = 'critical'
+os.umask(0o077)
+protocol = sys.stdout
+sys.stdout = sys.stderr
+from browser_use.mcp.server import BrowserUseServer
+from browser_use.browser import BrowserProfile, BrowserSession
+from browser_use.tools.service import Tools
+
+CATALOG = json.loads((Path(__file__).parent / 'browser-runtime/tools.json').read_text())
+ALLOWED = {tool['name'] for tool in CATALOG}
+
+class BrowserDisconnected(Exception):
+    pass
+
+
+def require_browser(session):
+    if not session or not session.is_cdp_connected:
+        raise BrowserDisconnected('Browser connection lost. Chrome closed or disconnected.')
+
+
+async def call_browser(server, name, parameters):
+    require_browser(server.browser_session)
+    try:
+        content = await server._execute_tool(name, parameters)
+    except Exception as error:
+        require_browser(server.browser_session)
+        # Provider exception text can contain cookies or private connection URLs.
+        return {'isError': True, 'content': [{'type': 'text', 'text':
+            type(error).__name__ + ': browser action failed. Inspect the page and try another action.'}]}
+    require_browser(server.browser_session)
+    return {'content': [v.model_dump(by_alias=True, exclude_none=True) for v in content]
+            if isinstance(content, list) else [{'type': 'text', 'text': content}]}
+
+
+async def serve():
+    server = BrowserUseServer()
+    domains = set()
+    owned = False
+    copied_profile = None
+    async def close_browser():
+        try:
+            if server.browser_session:
+                await asyncio.wait_for(server.browser_session.kill() if owned else server.browser_session.stop(), 5)
+        finally:
+            if copied_profile:
+                shutil.rmtree(copied_profile, ignore_errors=True)
+    async def stop():
+        with contextlib.suppress(Exception):
+            await close_browser()
+        os._exit(0)
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        asyncio.get_running_loop().add_signal_handler(sig, lambda: asyncio.create_task(stop()))
+    async def save(path):
+        state = await server.browser_session.export_storage_state()
+        def selected(host):
+            host = host.lstrip('.').lower()
+            return any(d == host or d.endswith('.' + host) for d in domains)
+        state['cookies'] = [c for c in state.get('cookies', []) if selected(c['domain'])]
+        state['origins'] = [o for o in state.get('origins', []) if selected(urlparse(o['origin']).hostname or '')]
+        target = Path(path)
+        target.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        tmp = target.with_suffix('.tmp')
+        tmp.write_text(json.dumps(state)); tmp.chmod(0o600); tmp.replace(target)
+        return {'domains': sorted(domains)}
+    while line := await asyncio.to_thread(sys.stdin.readline):
+        request = json.loads(line)
+        try:
+            method, args = request['method'], request.get('args', {})
+            if method == 'start':
+                owned = not bool(args.get('cdp_url'))
+                domains.update(args.pop('domains', []))
+                # Give the library a value, not our export path: its shutdown save
+                # must not overwrite the site-filtered transfer file.
+                if isinstance(args.get('storage_state'), str):
+                    args['storage_state'] = json.loads(Path(args['storage_state']).read_text())
+                profile = BrowserProfile(**args, enable_default_extensions=False, args=['--disable-extensions'], keep_alive=not owned)
+                if owned and str(profile.user_data_dir) != str(args.get('user_data_dir')) and Path(profile.user_data_dir).name.startswith('browser-use-user-data-dir-'):
+                    copied_profile = profile.user_data_dir
+                server.browser_session = BrowserSession(browser_profile=profile)
+                await server.browser_session.start()
+                server.tools = Tools()
+                result = {'started': True}
+            elif method == 'call':
+                name = args['name']
+                if name not in ALLOWED:
+                    raise ValueError('Unsupported browser control')
+                parameters = args.get('arguments', {})
+                if name == 'browser_navigate':
+                    host = urlparse(parameters['url']).hostname
+                    if host: domains.add(host.lower())
+                result = await call_browser(server, name, parameters)
+                # Followed links and sign-in redirects belong to this task's active tab.
+                require_browser(server.browser_session)
+                page = await server.browser_session.get_current_page()
+                if page and name != 'browser_list_tabs':
+                    host = urlparse(await page.get_url()).hostname
+                    if host: domains.add(host.lower())
+            elif method == 'export':
+                result = await save(args['path'])
+            elif method == 'close':
+                await close_browser()
+                result = {'closed': True}
+            else:
+                raise ValueError('Unknown browser operation')
+            protocol.write(json.dumps({'id': request['id'], 'result': result}) + '\n'); protocol.flush()
+            if method == 'close': return
+        except Exception as error:
+            # Avoid exporting exception text that can contain connection URLs or cookies.
+            protocol.write(json.dumps({'id': request['id'], 'error': {'code': 'connection_failed', 'message': str(error) if isinstance(error, BrowserDisconnected) else type(error).__name__ + ': browser service failed.'}}) + '\n'); protocol.flush()
+    if server.browser_session:
+        with contextlib.suppress(Exception):
+            await close_browser()
+
+if __name__ == '__main__':
+    asyncio.run(serve())

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

@@ -0,0 +1,38 @@
+export declare const browserVersion = "0.13.10";
+export declare function browserName(method: any): string | undefined;
+export declare function browserConfig(method: any, config: any): any;
+export declare const browserDirectory: (run: string) => string;
+export declare function browserBinding(name?: string): string;
+export declare function configureBrowser(name: string, cdp?: string): {
+    connection: string;
+    configured: boolean;
+};
+export declare function localChromeProfile(home?: string, platform?: NodeJS.Platform): {
+    user_data_dir: string;
+    profile_directory: string;
+} | undefined;
+export declare function mergeSessions(previous: any, current: any, domains: string[]): {
+    cookies: any[];
+    origins: any[];
+};
+export declare class BrowserService {
+    private id;
+    private pending;
+    private stopped;
+    private child;
+    private queue;
+    constructor(python: string);
+    private fail;
+    request(method: string, args?: any, signal?: AbortSignal): Promise<any>;
+    close(): Promise<void>;
+}
+export declare function openBrowser(method: any, config: any, run: string, signal?: AbortSignal): Promise<{
+    connections: {
+        [x: string]: {
+            call: (tool: string, args: any, signal: AbortSignal) => Promise<any>;
+        };
+    };
+    service: BrowserService;
+    root: string;
+    close(): Promise<void>;
+} | undefined>;

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

@@ -0,0 +1,203 @@
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline';
+import { readFileSync, existsSync, mkdirSync, openSync, closeSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { methodCache, prepareRuntime } from './prepare.js';
+import { writePrivateJson } from './files.js';
+import { authoringPath } from './authoring.js';
+export const browserVersion = '0.13.10';
+const assets = fileURLToPath(new URL('./browser-runtime/', import.meta.url));
+const catalog = JSON.parse(readFileSync(join(assets, 'tools.json'), 'utf8'));
+const observers = new Set(['browser_get_state', 'browser_get_html', 'browser_screenshot', 'browser_list_tabs']);
+export function browserName(method) {
+    const names = [...new Set(Object.values(method.steps).flatMap((s) => [s.do, s.check]).filter(e => e?.browser).map(e => e.browser.split('.')[1]))];
+    if (names.length > 1)
+        throw Error('Use one browser connection per run.');
+    return names[0];
+}
+export function browserConfig(method, config) {
+    const name = browserName(method);
+    if (!name)
+        return config;
+    const tools = { ...config.tools };
+    for (const t of catalog) {
+        const def = { description: t.description, connection: name, tool: t.name, parameters: t.inputSchema, effects: observers.has(t.name) ? [] : [name] };
+        if (tools[t.name] && JSON.stringify(tools[t.name]) !== JSON.stringify(def))
+            throw Error(`Browser tool conflicts with custom tool: ${t.name}`);
+        tools[t.name] = def;
+    }
+    return { ...config, environment: { ...config.environment, [name]: config.environment?.[name] ?? 'method-browser:default' }, tools };
+}
+export const browserDirectory = (run) => join(methodCache(), 'browser', 'runs', createHash('sha256').update(resolve(run)).digest('hex'));
+export function browserBinding(name = 'default') {
+    if (!/^[a-z][a-z0-9_-]*$/.test(name))
+        throw Error('Invalid browser connection name.');
+    return join(methodCache(), 'browser', 'bindings', name);
+}
+export function configureBrowser(name, cdp) {
+    const root = browserBinding(name);
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    if (cdp) {
+        const url = new URL(cdp);
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+            throw Error('Use a browser endpoint without credentials or query parameters.');
+    }
+    writePrivateJson(join(root, 'connection.json'), { ...(cdp ? { cdp_url: cdp } : {}) });
+    if (existsSync(join(root, 'session.json')))
+        unlinkSync(join(root, 'session.json'));
+    return { connection: `method-browser:${name}`, configured: true };
+}
+export function localChromeProfile(home = homedir(), platform = process.platform) {
+    if (platform !== 'darwin')
+        return undefined;
+    const root = join(home, 'Library', 'Application Support', 'Google', 'Chrome');
+    const file = join(root, 'Local State');
+    if (!existsSync(file))
+        return undefined;
+    const state = JSON.parse(readFileSync(file, 'utf8'));
+    const profile = state.profile?.last_used ?? 'Default';
+    if (typeof profile !== 'string' || profile !== profile.split(/[\\/]/).pop() || !existsSync(join(root, profile)))
+        throw Error('The selected Chrome profile is unavailable. Open Chrome and select a profile, then retry.');
+    return { user_data_dir: root, profile_directory: profile };
+}
+export function mergeSessions(previous, current, domains) {
+    const selected = (host) => domains.some(d => d === host.replace(/^\./, '') || d.endsWith('.' + host.replace(/^\./, '')));
+    return { cookies: [...(previous.cookies ?? []).filter((c) => !selected(c.domain)), ...(current.cookies ?? [])], origins: [...(previous.origins ?? []).filter((o) => !selected(new URL(o.origin).hostname)), ...(current.origins ?? [])] };
+}
+export class BrowserService {
+    id = 0;
+    pending = new Map();
+    stopped = false;
+    child;
+    queue = Promise.resolve();
+    constructor(python) {
+        this.child = spawn(python, [fileURLToPath(new URL('./browser-service.py', import.meta.url))], { stdio: ['pipe', 'pipe', 'ignore'], env: { ...process.env, ANONYMIZED_TELEMETRY: 'false' } });
+        createInterface({ input: this.child.stdout }).on('line', line => { try {
+            const r = JSON.parse(line), p = this.pending.get(r.id);
+            if (p) {
+                this.pending.delete(r.id);
+                r.error ? p.reject(Object.assign(Error(r.error.message), { code: r.error.code })) : p.resolve(r.result);
+            }
+        }
+        catch {
+            this.fail(Error('Invalid browser response'));
+        } });
+        this.child.stdin.on('error', e => this.fail(e));
+        this.child.on('error', e => { this.stopped = true; this.fail(e); });
+        this.child.on('exit', () => { this.stopped = true; this.fail(Object.assign(Error('Browser service stopped.'), { code: 'connection_failed' })); });
+    }
+    fail(e) { for (const p of this.pending.values())
+        p.reject(e); this.pending.clear(); }
+    request(method, args = {}, signal) {
+        const action = async () => {
+            if (this.stopped)
+                throw Object.assign(Error('Browser service stopped.'), { code: 'connection_failed' });
+            if (signal?.aborted)
+                throw signal.reason;
+            const id = ++this.id;
+            return new Promise((resolve, reject) => {
+                const abort = () => { clean(); this.pending.delete(id); this.child.kill('SIGTERM'); reject(signal?.reason ?? Object.assign(Error('Browser operation timed out.'), { code: 'connection_failed' })); };
+                const timer = setTimeout(abort, 120_000);
+                const clean = () => { clearTimeout(timer); signal?.removeEventListener('abort', abort); };
+                this.pending.set(id, { resolve: v => { clean(); resolve(v); }, reject: e => { clean(); reject(e); } });
+                signal?.addEventListener('abort', abort, { once: true });
+                this.child.stdin.write(JSON.stringify({ id, method, args }) + '\n');
+            });
+        };
+        const next = this.queue.then(action);
+        this.queue = next.catch(() => { });
+        return next;
+    }
+    async close() { if (this.stopped)
+        return; try {
+        await this.request('close');
+    }
+    finally {
+        this.child.kill('SIGTERM');
+    } }
+}
+export async function openBrowser(method, config, run, signal) {
+    const name = browserName(method);
+    if (!name)
+        return undefined;
+    const root = browserDirectory(run);
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const binding = String(config.environment[name]);
+    if (!binding.startsWith('method-browser:'))
+        throw Error('Connect the browser with method browser connect, then use its method-browser connection name.');
+    const shared = browserBinding(binding.slice('method-browser:'.length));
+    mkdirSync(shared, { recursive: true, mode: 0o700 });
+    const selection = join(root, 'connection.json');
+    let settings = existsSync(selection) ? JSON.parse(readFileSync(selection, 'utf8')) : existsSync(join(shared, 'connection.json')) ? JSON.parse(readFileSync(join(shared, 'connection.json'), 'utf8')) : {};
+    if (!existsSync(selection) && binding === 'method-browser:default' && !settings.cdp_url && !settings.user_data_dir) {
+        const profile = localChromeProfile();
+        if (profile)
+            settings = { ...settings, ...profile };
+    }
+    if (!existsSync(selection))
+        writePrivateJson(selection, settings);
+    const state = join(root, 'session.json');
+    const profileSource = settings.user_data_dir ? JSON.stringify([settings.user_data_dir, settings.profile_directory]) : 'private';
+    if (!existsSync(state) && existsSync(join(shared, 'session.json'))) {
+        const saved = JSON.parse(readFileSync(join(shared, 'session.json'), 'utf8'));
+        if (profileSource === 'private' || saved.profile_source === profileSource)
+            writePrivateJson(state, { cookies: saved.cookies, origins: saved.origins });
+    }
+    const metadataFile = join(root, 'receipt.json');
+    const metadata = existsSync(metadataFile) ? JSON.parse(readFileSync(metadataFile, 'utf8')) : {};
+    const prepared = await prepareRuntime(assets, { allow_local_processes: true }, { steps: {} });
+    let lock;
+    const lockFile = join(shared, 'attached.lock');
+    if (settings.cdp_url) {
+        if (existsSync(lockFile)) {
+            try {
+                process.kill(Number(readFileSync(lockFile, 'utf8')), 0);
+            }
+            catch (e) {
+                if (e.code === 'ESRCH')
+                    unlinkSync(lockFile);
+            }
+        }
+        try {
+            lock = openSync(lockFile, 'wx', 0o600);
+            writeFileSync(lock, String(process.pid));
+        }
+        catch {
+            throw Object.assign(Error('Another Method run controls this Chrome session. Wait for it to finish, or select a separate browser connection.'), { code: 'needs_input' });
+        }
+    }
+    const release = () => { if (lock !== undefined) {
+        closeSync(lock);
+        lock = undefined;
+        unlinkSync(lockFile);
+    } };
+    const service = new BrowserService(prepared.config.runtimes.python.command);
+    const executable = process.env.METHOD_BROWSER_EXECUTABLE ?? ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/usr/bin/chromium', '/usr/bin/chromium-browser', '/usr/bin/google-chrome'].find(p => existsSync(p));
+    try {
+        await service.request('start', { user_data_dir: join(root, 'profile'), headless: process.env.METHOD_BROWSER_HEADLESS !== '0', ...(executable ? { executable_path: authoringPath(executable) } : {}), ...settings, ...(existsSync(state) ? { storage_state: state } : {}), domains: metadata.domains ?? [] }, signal);
+    }
+    catch (e) {
+        await service.close().catch(() => { });
+        release();
+        throw Object.assign(Error('Browser could not start. If Chrome is open, close it and retry so Method can copy its sign-ins. Otherwise, install Chrome or select a running browser with method browser connect --cdp URL.'), { code: 'needs_input' });
+    }
+    writePrivateJson(join(run, 'browser-runtime.json'), { provider: 'browser-use', version: browserVersion, connection: name, tools: catalog });
+    return { connections: { [name]: { call: (tool, args, signal) => service.request('call', { name: tool, arguments: args }, signal) } }, service, root,
+        async close() { try {
+            const receipt = await service.request('export', { path: state });
+            writePrivateJson(metadataFile, { ...receipt, version: browserVersion, binding });
+            const prior = existsSync(join(shared, 'session.json')) ? JSON.parse(readFileSync(join(shared, 'session.json'), 'utf8')) : {};
+            writePrivateJson(join(shared, 'session.json'), { ...mergeSessions(prior.profile_source === profileSource || profileSource === 'private' ? prior : {}, JSON.parse(readFileSync(state, 'utf8')), receipt.domains), profile_source: profileSource });
+        }
+        finally {
+            try {
+                await service.close();
+            }
+            finally {
+                release();
+            }
+        } } };
+}

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

@@ -0,0 +1,13 @@
+/** Check supported agent access without starting a model request. Custom commands remain operator-owned. */
+export declare function checkAgents(profiles: Record<string, any>): Promise<void>;
+/**
+ * The model profiles of a run. With this computer's own model key (method config model-key) and no local agent,
+ * hosted profiles call OpenRouter with that key, and classify steps call Jev with it (config.classification).
+ */
+export declare function resolveAgentProfiles(method: any, config: any, agent?: string, hostedModel?: string): Promise<any>;
+/** What a run needs from the Method account: hosted models for unconfigured call and agent steps, and classification. */
+export declare function accountNeeds(method: any, config: any, agent?: string): {
+    models: boolean;
+    classification: boolean;
+};
+export declare function checkConfiguration(config: any): Promise<void>;

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

@@ -0,0 +1,68 @@
+import { resolveModels } from '@withmethod/runtime/agents.js';
+import { executable } from '@withmethod/runtime/io.js';
+import { directBackends } from '@withmethod/runtime/model.js';
+import { command } from './prepare.js';
+import { announceOwnKey, loadOwnKey, ownKeyClassification, ownKeyEnv } from './own-model-key.js';
+/** Check supported agent access without starting a model request. Custom commands remain operator-owned. */
+export async function checkAgents(profiles) {
+    const checked = new Set();
+    for (const profile of Object.values(profiles)) {
+        if (!['codex', 'claude'].includes(profile.backend) || profile.command || checked.has(profile.backend))
+            continue;
+        checked.add(profile.backend);
+        try {
+            const result = await command(profile.backend, profile.backend === 'codex' ? ['login', 'status'] : ['auth', 'status'], process.cwd());
+            if (profile.backend === 'claude' && JSON.parse(result.stdout).loggedIn !== true)
+                throw Error('Not signed in.');
+        }
+        catch (error) {
+            throw Object.assign(Error(`${profile.backend} access check failed. Sign in with ${profile.backend}, then continue this run. ${error.message}`), { code: 'needs_input' });
+        }
+    }
+}
+/**
+ * The model profiles of a run. With this computer's own model key (method config model-key) and no local agent,
+ * hosted profiles call OpenRouter with that key, and classify steps call Jev with it (config.classification).
+ */
+export async function resolveAgentProfiles(method, config, agent, hostedModel) {
+    const profiles = await resolveModels(method, config, { agent, hostedModel });
+    const env = ownKeyEnv();
+    if (!env)
+        return profiles;
+    const classifies = Object.values(method.steps ?? {}).some((step) => [step?.do, step?.check].some(exec => exec?.kind === 'classify'));
+    // A local agent (--agent) runs the model steps; the own key still classifies.
+    const hosted = !agent && Object.values(profiles).some((profile) => profile?.backend === 'method');
+    if (!hosted && !classifies)
+        return profiles;
+    if (classifies && !config.classification?.api_key_env)
+        config.classification = ownKeyClassification(env);
+    // Hosted profiles stay hosted: the run sends their requests with the own key (hostedModelsFor).
+    loadOwnKey(env);
+    announceOwnKey();
+    return profiles;
+}
+/** What a run needs from the Method account: hosted models for unconfigured call and agent steps, and classification. */
+export function accountNeeds(method, config, agent) {
+    // Every run asks this first, a resumed one too: the own key's value comes from the device store by name.
+    const env = ownKeyEnv();
+    if (env)
+        loadOwnKey(env, false);
+    const steps = Object.values(method.steps ?? {});
+    const execs = steps.flatMap(step => [step.do, step.check]).filter(exec => exec?.kind);
+    return {
+        // A step on a local-agent entry of the Method's models needs no account.
+        models: !agent && !config.models?.default && execs.some(exec => ['call', 'agent'].includes(exec.kind) && !config.models?.[exec.model] && !method.models?.[exec.model ?? 'default']?.agent),
+        classification: execs.some(exec => exec.kind === 'classify') && !config.classification?.api_key_env && !env,
+    };
+}
+export async function checkConfiguration(config) {
+    for (const profile of Object.values(config.runtimes ?? {}))
+        await executable(profile.command);
+    for (const profile of Object.values(config.models ?? {})) {
+        if (directBackends.includes(profile.backend) && profile.backend !== 'method' && !process.env[profile.api_key_env])
+            throw Error(`Missing environment variable: ${profile.api_key_env}`);
+        if (['codex', 'claude'].includes(profile.backend))
+            await executable(profile.command ?? profile.backend);
+    }
+    await checkAgents(config.models ?? {});
+}

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

@@ -0,0 +1,4 @@
+import type { ClassificationProvider } from '@withmethod/runtime';
+import { MethodClient } from './method-client.js';
+/** Use the same Method account and server as the run. Each evaluation is one attempt. */
+export declare function managedClassification(client: MethodClient): ClassificationProvider;

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { classificationByteLimit, validateClassification } from '@withmethod/runtime/classification.js';
+const Identity = z.strictObject({ provider: z.literal('typesafe'), model: z.string().trim().min(1) });
+/** Use the same Method account and server as the run. Each evaluation is one attempt. */
+export function managedClassification(client) {
+    const options = (signal) => ({ signal, stallMs: 30_000, maxResponseBytes: classificationByteLimit });
+    return {
+        async resolve(signal) {
+            return Identity.parse(await client.request('/api/cli/classifications/model', 'GET', undefined, true, options(signal)));
+        },
+        async evaluate(request, signal) {
+            if (Buffer.byteLength(JSON.stringify(request), 'utf8') > classificationByteLimit)
+                throw Object.assign(Error('Classification input exceeds request limit.'), { code: 'input_limit' });
+            let answer;
+            try {
+                answer = await client.request('/api/cli/classifications', 'POST', request, true, options(signal));
+            }
+            catch (error) {
+                if (error.status === 409)
+                    throw Object.assign(Error("This run's classifier version is unavailable. Start a new run to use the current default."), { code: 'classification_version_unavailable' });
+                throw error;
+            }
+            validateClassification(answer, request, { provider: 'typesafe', model: request.model });
+            return answer;
+        },
+    };
+}

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

@@ -0,0 +1,23 @@
+import type { MethodClient } from './method-client.js';
+/** Where the production runs of a Method run in one environment: on the organization's workers, or on Method Cloud. */
+export type Placement = 'workers' | 'cloud';
+export declare const environmentPattern: RegExp;
+/** The placement flags of `method publish`: --cloud or --workers, and --env NAME (default production). */
+export declare function placementFlags(args: string[]): {
+    placement: Placement;
+    environment: string;
+} | undefined;
+/** Set where the production runs of a Method run in one environment. */
+export declare function setPlacement(client: MethodClient, methodId: string, environment: string, placement: Placement): Promise<{
+    environment: string;
+    placement: Placement;
+    updated_at: string | null;
+}>;
+/**
+ * Publish, then set the placement when --cloud or --workers is given. The flags are checked before the publish. When
+ * the organization cannot use Method Cloud, the version stays published and the result says why the placement did not
+ * change.
+ */
+export declare function publishWithPlacement<T extends {
+    workflow_id: string;
+}>(client: MethodClient, args: string[], publish: () => Promise<T>): Promise<T>;

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

@@ -0,0 +1,43 @@
+export const environmentPattern = /^[a-z0-9][a-z0-9-]{0,39}$/;
+/** The placement flags of `method publish`: --cloud or --workers, and --env NAME (default production). */
+export function placementFlags(args) {
+    const cloud = args.includes('--cloud'), workers = args.includes('--workers');
+    if (cloud && workers)
+        throw Error('Use --cloud or --workers, not both.');
+    const at = args.findIndex(arg => arg === '--env' || arg.startsWith('--env='));
+    const environment = at < 0 ? 'production' : args[at].startsWith('--env=') ? args[at].slice(6) : args[at + 1];
+    if (!environment || !environmentPattern.test(environment))
+        throw Error('Use --env NAME: lowercase letters, digits, and hyphens.');
+    if (!cloud && !workers) {
+        if (at >= 0)
+            throw Error('Use --env with --cloud or --workers.');
+        return undefined;
+    }
+    return { placement: cloud ? 'cloud' : 'workers', environment };
+}
+/** Set where the production runs of a Method run in one environment. */
+export async function setPlacement(client, methodId, environment, placement) {
+    return client.request(`/api/methods/${encodeURIComponent(methodId)}/placements/${encodeURIComponent(environment)}`, 'PUT', { placement });
+}
+/**
+ * Publish, then set the placement when --cloud or --workers is given. The flags are checked before the publish. When
+ * the organization cannot use Method Cloud, the version stays published and the result says why the placement did not
+ * change.
+ */
+export async function publishWithPlacement(client, args, publish) {
+    const wanted = placementFlags(args);
+    const published = await publish();
+    if (!wanted)
+        return published;
+    try {
+        const placement = await setPlacement(client, published.workflow_id, wanted.environment, wanted.placement);
+        return { ...published, placement: { environment: placement.environment, placement: placement.placement } };
+    }
+    catch (error) {
+        process.exitCode = 1;
+        const message = error.code === 'cloud_not_enabled'
+            ? 'Method Cloud is not on for your organization. Production runs still use your workers.'
+            : `The placement did not change: ${error.message}`;
+        return { ...published, placement: { environment: wanted.environment, error: message } };
+    }
+}

package/dist/packages/sdk/src/computer-settings.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/** METHOD_CONFIG_DIR selects another folder for sign-ins and computer settings (tests use a temporary one). */
+export declare const configRoot: () => string;
+export declare const computerFile: () => string;
+declare const Settings: z.ZodObject<{
+    agent: z.ZodOptional<z.ZodEnum<["codex", "claude"]>>;
+    bindings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    classification_key_env: z.ZodOptional<z.ZodString>;
+    model_key_env: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    bindings: Record<string, Record<string, string>>;
+    agent?: "codex" | "claude" | undefined;
+    classification_key_env?: string | undefined;
+    model_key_env?: string | undefined;
+}, {
+    agent?: "codex" | "claude" | undefined;
+    bindings?: Record<string, Record<string, string>> | undefined;
+    classification_key_env?: string | undefined;
+    model_key_env?: string | undefined;
+}>;
+export type ComputerSettings = z.infer<typeof Settings>;
+/** The settings of this computer: the local agent, connection bindings, and an own model key. Nothing in a Method file. */
+export declare function readComputerSettings(): ComputerSettings;
+export declare function updateComputerSettings(change: (settings: ComputerSettings) => void): ComputerSettings;
+export declare function bindConnectionValue(methodId: string, name: string, value: string): void;
+/** method config: print the computer settings, set the local agent, or turn the own model key on or off. */
+export declare function configCommand(args: string[]): Promise<void>;
+export {};

package/dist/packages/sdk/src/computer-settings.js

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { writePrivateJson } from './files.js';
+/** METHOD_CONFIG_DIR selects another folder for sign-ins and computer settings (tests use a temporary one). */
+export const configRoot = () => process.env.METHOD_CONFIG_DIR || join(homedir(), '.config', 'method');
+export const computerFile = () => join(configRoot(), 'computer.json');
+// Only settings of this computer. Run limits belong to each Method (format 3.4 limits), never to the computer.
+const Settings = z.object({
+    agent: z.enum(['codex', 'claude']).optional(),
+    // METHOD_ID -> connection name -> a folder path, or a connection value (URL or method-browser:NAME).
+    bindings: z.record(z.string(), z.record(z.string(), z.string())).default({}),
+    // The environment variable with this computer's own OpenRouter key: classify then calls Jev directly with it.
+    classification_key_env: z.string().regex(/^[A-Z_][A-Z0-9_]*$/).optional(),
+    // The name of this computer's own OpenRouter key (method config model-key): hosted model and classify steps use it.
+    model_key_env: z.string().regex(/^[A-Z_][A-Z0-9_]*$/).optional(),
+});
+/** The settings of this computer: the local agent, connection bindings, and an own model key. Nothing in a Method file. */
+export function readComputerSettings() {
+    const file = computerFile();
+    if (!existsSync(file))
+        return { bindings: {} };
+    try {
+        return Settings.parse(JSON.parse(readFileSync(file, 'utf8')));
+    }
+    catch (error) {
+        throw Error(`${file} is not valid: ${error.message.slice(0, 300)} Fix or delete the file.`);
+    }
+}
+export function updateComputerSettings(change) {
+    const settings = readComputerSettings();
+    change(settings);
+    const parsed = Settings.parse(settings);
+    writePrivateJson(computerFile(), parsed);
+    return parsed;
+}
+export function bindConnectionValue(methodId, name, value) {
+    updateComputerSettings(settings => { settings.bindings[methodId] = { ...settings.bindings[methodId], [name]: value }; });
+}
+/** method config: print the computer settings, set the local agent, or turn the own model key on or off. */
+export async function configCommand(args) {
+    const [key, value, extra] = args;
+    if (!key) {
+        process.stdout.write(JSON.stringify({ file: computerFile(), ...readComputerSettings() }, null, 2) + '\n');
+        return;
+    }
+    if (key === 'model-key')
+        return (await import('./own-model-key.js')).modelKeyCommand(args.slice(1));
+    if (key !== 'agent' || !value || extra !== undefined || !['codex', 'claude', 'none'].includes(value))
+        throw Error('Use method config, method config agent codex|claude|none, or method config model-key [--off].');
+    const saved = updateComputerSettings(settings => { if (value === 'none')
+        delete settings.agent;
+    else
+        settings.agent = value; });
+    process.stdout.write(saved.agent ? `Model steps run with the local ${saved.agent} agent on this computer.\n` : 'Model steps use the Method\'s models and the account default.\n');
+}