agency-lang 0.13.4 → 0.14.0

package/dist/lib/cli/remote/commands/deploy.d.ts

@@ -5,4 +5,8 @@ export type RemoteDeployOptions = {
     apiKeyEnv?: string;
     dryRun?: boolean;
 };
-export declare function runDeploy(file: string, options: RemoteDeployOptions, context: RemoteCommandContext): Promise<void>;
+/** What actually happened, for callers that gate follow-up work on a real
+ *  upload (schedule add's deploy-if-missing). A deploy error never produces an
+ *  outcome — that path exits the process. */
+export type RunDeployOutcome = "deployed" | "aborted" | "preview";
+export declare function runDeploy(file: string, options: RemoteDeployOptions, context: RemoteCommandContext): Promise<RunDeployOutcome>;

package/dist/lib/cli/remote/commands/deploy.js

@@ -17,7 +17,7 @@ export async function runDeploy(file, options, context) {
             color.dim("Nodes and functions must be marked 'export' to be served."));
         if (!(await confirmDeployWithoutExports({ dryRun: options.dryRun }))) {
             console.log("Aborted.");
-            return;
+            return "aborted";
         }
     }
     const outcome = await deploy(file, context.config, options);
@@ -26,16 +26,17 @@ export async function runDeploy(file, options, context) {
         process.exit(1);
     }
     if (outcome.kind !== "deployed") {
-        return; // a --dry-run preview never writes a binding
+        return "preview"; // a --dry-run preview never writes a binding
     }
     const base = serveBaseUrl(outcome.endpointUrls);
     const address = base ? parseServeBaseUrl(base) : null;
     if (!address) {
         console.log(color.yellow("Deployed, but could not derive a serve URL to link."));
-        return;
+        return "deployed";
     }
     writeBinding(context.configPath, address);
     console.log(`\n${color.green("Linked")} this directory to ${color.bold(address.filename)}.`);
+    return "deployed";
 }
 function tryCountExports(file, config) {
     try {

package/dist/lib/cli/remote/commands/secrets.d.ts

@@ -0,0 +1,36 @@
+import type { ProjectCommandOptions, RemoteCommandContext } from "./util.js";
+import { SecretRequestError } from "../../statelog/secretsClient.js";
+import type { SecretValueSources } from "../secretsInput.js";
+/** The set recipe's terminal dependencies, injected by the Commander action
+ *  and faked in tests. Same fields as SecretValueSources minus fromEnv, which
+ *  arrives via options. */
+export type SecretsSetIO = Omit<SecretValueSources, "fromEnv">;
+export type SecretsSetResult = {
+    kind: "set";
+} | {
+    kind: "canceled";
+};
+/** THE one presenter for SecretRequestError, used by all four recipes
+ *  (including every collected import failure): redacts any additional known
+ *  values BEFORE terminal-safe escaping, then appends the trusted one-line
+ *  full-access-key guidance on status 401/403. Stays one line so import
+ *  summaries keep one outcome per line. */
+export declare function presentSecretError(error: SecretRequestError, sensitiveValues?: string[]): string;
+export declare function runSecretsSet(name: string, options: ProjectCommandOptions & {
+    fromEnv?: string;
+}, context: RemoteCommandContext, io: SecretsSetIO): Promise<SecretsSetResult>;
+export declare function runSecretsList(options: ProjectCommandOptions, context: RemoteCommandContext): Promise<void>;
+export declare function runSecretsRm(name: string, options: ProjectCommandOptions, context: RemoteCommandContext): Promise<void>;
+export type ImportResult = {
+    kind: "declined";
+} | {
+    kind: "succeeded";
+} | {
+    kind: "failed";
+};
+export type SecretsImportIO = {
+    stdinIsTty: boolean;
+    readStdin: () => Promise<string>;
+    confirm: (question: string) => Promise<boolean>;
+};
+export declare function runSecretsImport(file: string | undefined, options: ProjectCommandOptions, context: RemoteCommandContext, io: SecretsImportIO): Promise<ImportResult>;

package/dist/lib/cli/remote/commands/secrets.js

@@ -0,0 +1,178 @@
+// `agency remote secrets` — thin recipes over the sealed secrets client. The
+// store is write-only (no route returns a value), and these recipes uphold the
+// CLI's matching invariants: a value reaches `set` only through injected seams
+// (never argv), and no code path prints one — presentSecretError is the single
+// place that composes redaction, terminal-safe escaping, and trusted auth
+// guidance, in that order. Recipes render and return semantic outcomes; the
+// Commander actions own process.exitCode.
+import * as fs from "fs";
+import * as path from "path";
+import { color } from "../../../utils/termcolors.js";
+import { resolveProjectTarget, fail } from "./util.js";
+import { createSecretsClient, SecretRequestError } from "../../statelog/secretsClient.js";
+import { redactValues } from "../../statelog/redact.js";
+import { resolveSecretValue, parseEnvSource, terminalSafe } from "../secretsInput.js";
+/** THE one presenter for SecretRequestError, used by all four recipes
+ *  (including every collected import failure): redacts any additional known
+ *  values BEFORE terminal-safe escaping, then appends the trusted one-line
+ *  full-access-key guidance on status 401/403. Stays one line so import
+ *  summaries keep one outcome per line. */
+export function presentSecretError(error, sensitiveValues = []) {
+    const safe = terminalSafe(redactValues(error.message, sensitiveValues));
+    if (error.status === 401 || error.status === 403) {
+        return `${safe} — Secret management needs a full-access API key; invoke-only keys and sessions are rejected.`;
+    }
+    return safe;
+}
+export async function runSecretsSet(name, options, context, io) {
+    const target = resolveProjectTarget(context, options);
+    const resolved = await resolveSecretValue(name, { ...io, fromEnv: options.fromEnv });
+    if (resolved.kind === "canceled") {
+        console.log("Canceled.");
+        return { kind: "canceled" };
+    }
+    if (resolved.kind === "error") {
+        fail(resolved.message);
+    }
+    const client = createSecretsClient(target.origin, target.projectSlug, target.apiKey);
+    try {
+        await client.set(name, resolved.value);
+    }
+    catch (error) {
+        failSecretRequest(error);
+    }
+    console.log(`${color.green("Set")} secret ${terminalSafe(name)}.`);
+    // The hint shows real call-site syntax, so the name renders as an actual
+    // string literal — JSON.stringify quotes AND escapes it in one step (a
+    // terminalSafe'd name would end up double-quoted here).
+    console.log(`Available to hosted runs as env(${JSON.stringify(name)}) from the next invocation.`);
+    return { kind: "set" };
+}
+export async function runSecretsList(options, context) {
+    const target = resolveProjectTarget(context, options);
+    const client = createSecretsClient(target.origin, target.projectSlug, target.apiKey);
+    let secrets;
+    try {
+        secrets = await client.list();
+    }
+    catch (error) {
+        failSecretRequest(error);
+    }
+    console.log(formatSecretsTable(secrets));
+}
+export async function runSecretsRm(name, options, context) {
+    const target = resolveProjectTarget(context, options);
+    const client = createSecretsClient(target.origin, target.projectSlug, target.apiKey);
+    try {
+        await client.delete(name);
+    }
+    catch (error) {
+        failSecretRequest(error);
+    }
+    console.log(`${color.green("Removed")} secret ${terminalSafe(name)}.`);
+}
+export async function runSecretsImport(file, options, context, io) {
+    const target = resolveProjectTarget(context, options);
+    const fromStdin = file === "-";
+    const sourceName = fromStdin ? "<stdin>" : (file ?? ".env");
+    // The file argument is user/argv-controlled display text like any other.
+    const safeSource = terminalSafe(sourceName);
+    let text;
+    if (fromStdin) {
+        text = await io.readStdin();
+    }
+    else {
+        const sourcePath = path.resolve(process.cwd(), sourceName);
+        try {
+            text = fs.readFileSync(sourcePath, "utf-8");
+        }
+        catch (error) {
+            fail(`Could not read ${safeSource}: ${errorMessage(error)}`);
+        }
+    }
+    const { entries } = parseEnvSource(text);
+    if (entries.length === 0) {
+        fail(`No variables found in ${safeSource}.`);
+    }
+    // Confirmation is for FILE sources on a TTY only. An explicit `-` never
+    // prompts: after an interactive stdin entry the stream is exhausted at EOF,
+    // and choosing `-` is itself the authorization.
+    if (!fromStdin && io.stdinIsTty) {
+        const plural = entries.length === 1 ? "" : "s";
+        console.log(`Import ${entries.length} secret${plural} into project ${target.projectSlug} from ${safeSource}:`);
+        for (const entry of entries) {
+            console.log(`  ${terminalSafe(entry.name)}`);
+        }
+        if (!(await io.confirm("Continue?"))) {
+            console.log("Canceled.");
+            return { kind: "declined" };
+        }
+    }
+    const allValues = entries.map((entry) => entry.value);
+    const client = createSecretsClient(target.origin, target.projectSlug, target.apiKey);
+    const outcomes = [];
+    for (const entry of entries) {
+        if (entry.value === "") {
+            outcomes.push({ name: entry.name, ok: false, message: "empty value — nothing sent" });
+            continue;
+        }
+        try {
+            // The whole batch joins the FIRST redaction pass: a response echoing a
+            // DIFFERENT import's value that overlaps this one would otherwise be
+            // partially destroyed before the presenter's pass could match it.
+            await client.set(entry.name, entry.value, { alsoRedact: allValues });
+            outcomes.push({ name: entry.name, ok: true });
+        }
+        catch (error) {
+            if (!(error instanceof SecretRequestError)) {
+                throw error;
+            }
+            outcomes.push({
+                name: entry.name,
+                ok: false,
+                message: presentSecretError(error, allValues),
+            });
+        }
+    }
+    renderImportSummary(outcomes);
+    return outcomes.some((outcome) => !outcome.ok) ? { kind: "failed" } : { kind: "succeeded" };
+}
+function renderImportSummary(outcomes) {
+    const failed = outcomes.filter((outcome) => !outcome.ok);
+    const setCount = outcomes.length - failed.length;
+    if (failed.length === 0) {
+        const plural = setCount === 1 ? "" : "s";
+        console.log(`${color.green("Imported")} ${setCount} secret${plural}.`);
+        return;
+    }
+    console.log(`Imported ${setCount} of ${outcomes.length}; ${failed.length} failed:`);
+    for (const outcome of failed) {
+        console.log(`  ${terminalSafe(outcome.name)}: ${outcome.message}`);
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failSecretRequest(error) {
+    if (!(error instanceof SecretRequestError)) {
+        throw error;
+    }
+    fail(presentSecretError(error));
+}
+function formatSecretsTable(secrets) {
+    if (secrets.length === 0) {
+        return "No secrets set for this project. Use 'agency remote secrets set <NAME>' to add one.";
+    }
+    const rows = secrets.map((secret) => ({
+        name: terminalSafe(secret.name),
+        created: secret.createdAt.slice(0, 10),
+        updated: secret.updatedAt.slice(0, 10),
+    }));
+    const headers = { name: "Name", created: "Created", updated: "Updated" };
+    const columns = ["name", "created", "updated"];
+    const width = (column) => Math.max(headers[column].length, ...rows.map((row) => row[column].length)) + 2;
+    const render = (row) => columns
+        .map((column, index) => index === columns.length - 1 ? row[column] : row[column].padEnd(width(column)))
+        .join("");
+    return [render(headers), ...rows.map(render)].join("\n");
+}

package/dist/lib/cli/remote/confirmation.d.ts

@@ -3,4 +3,13 @@ export type ConfirmDeployOptions = {
     isTty?: boolean;
     prompt?: (question: string) => Promise<boolean>;
 };
+/** The deploy policy: a dry-run and a non-TTY run bypass the prompt and
+ *  proceed — only an interactive TTY asks. */
 export declare function confirmDeployWithoutExports(options?: ConfirmDeployOptions): Promise<boolean>;
+/** The raw readline yes/no lifecycle, policy-free. */
+export declare function confirmQuestion(question: string): Promise<boolean>;
+/** Hidden-input prompt for a secret value. Resolves undefined on cancellation
+ *  (ctrl-C / EOF) — `prompts` omits the answer key then — and preserves an
+ *  empty entry as "" so the caller can distinguish "typed nothing" from
+ *  "canceled". The name is untrusted display text and rendered terminal-safe. */
+export declare function promptSecretValue(name: string): Promise<string | undefined>;

package/dist/lib/cli/remote/confirmation.js

@@ -1,8 +1,13 @@
-// The "deploy an agent with no callable endpoints?" gate. Owns the TTY/readline
-// mechanics; `runDeploy` only asks whether it should proceed. Per Revision 2 a
-// dry-run and a non-TTY run bypass the prompt and proceed — only an interactive
-// TTY asks.
+// The remote commands' concrete terminal-prompt adapters: the raw yes/no
+// readline lifecycle, the hidden secret-value prompt, and the deploy-specific
+// "no callable endpoints?" gate built on top. This module owns terminal
+// mechanics only — each command keeps its own policy (when to ask, what a
+// decline means).
 import * as readline from "node:readline/promises";
+import prompts from "prompts";
+import { terminalSafe } from "./secretsInput.js";
+/** The deploy policy: a dry-run and a non-TTY run bypass the prompt and
+ *  proceed — only an interactive TTY asks. */
 export async function confirmDeployWithoutExports(options = {}) {
     if (options.dryRun) {
         return true;
@@ -11,10 +16,11 @@ export async function confirmDeployWithoutExports(options = {}) {
     if (!isTty) {
         return true;
     }
-    const prompt = options.prompt ?? defaultPrompt;
+    const prompt = options.prompt ?? confirmQuestion;
     return prompt("Upload anyway?");
 }
-async function defaultPrompt(question) {
+/** The raw readline yes/no lifecycle, policy-free. */
+export async function confirmQuestion(question) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     try {
         const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
@@ -24,3 +30,15 @@ async function defaultPrompt(question) {
         rl.close();
     }
 }
+/** Hidden-input prompt for a secret value. Resolves undefined on cancellation
+ *  (ctrl-C / EOF) — `prompts` omits the answer key then — and preserves an
+ *  empty entry as "" so the caller can distinguish "typed nothing" from
+ *  "canceled". The name is untrusted display text and rendered terminal-safe. */
+export async function promptSecretValue(name) {
+    const response = await prompts({
+        type: "invisible",
+        name: "value",
+        message: `Enter value for ${terminalSafe(name)}:`,
+    });
+    return typeof response.value === "string" ? response.value : undefined;
+}

package/dist/lib/cli/remote/secretsInput.d.ts

@@ -0,0 +1,54 @@
+export type SecretValueSources = {
+    /** --from-env VAR: the NAME of a local environment variable to copy. */
+    fromEnv?: string;
+    stdinIsTty: boolean;
+    readStdin: () => Promise<string>;
+    /** Hidden prompt; resolves undefined when the user cancels (ctrl-C / EOF). */
+    promptHidden: (name: string) => Promise<string | undefined>;
+    env: NodeJS.ProcessEnv;
+};
+export type SecretValueResult = {
+    kind: "value";
+    value: string;
+} | {
+    kind: "canceled";
+} | {
+    kind: "error";
+    message: string;
+};
+/** Where a secret's value comes from, in precedence order: --from-env wins;
+ *  else piped stdin; else the hidden TTY prompt. Never argv. */
+export declare function resolveSecretValue(name: string, sources: SecretValueSources): Promise<SecretValueResult>;
+/** One terminal "\r\n" or "\n" removed — exactly one, so a value meant to keep
+ *  a final newline supplies two (printf 'value\n\n'). Interior newlines are
+ *  untouched. */
+export declare function stripOneTrailingNewline(text: string): string;
+export type ParsedEnvSource = {
+    /** First-insertion key order; on a duplicate key the LAST assignment's value
+     *  wins (in the original position). No duplicate reporting — a `B=` line
+     *  inside a multiline quoted value is NOT an assignment, and
+     *  last-value-wins is the behavior that matters. */
+    entries: {
+        name: string;
+        value: string;
+    }[];
+};
+/** A small, OWNED dotenv parser. Deliberately not node:util's parseEnv: its
+ *  quoted-value handling differs across Node releases inside the supported
+ *  engine range (22.13.0 mis-splits `B="x=y"` into a bogus extra entry), and
+ *  secret values must parse identically on every supported version. Semantics
+ *  (pinned by tests): `NAME=value` lines; optional `export ` prefix; `#`
+ *  comments and blank lines skipped; single- or double-quoted values may span
+ *  lines and keep `=`/`#` literally; quoted content is LITERAL (no escape
+ *  expansion); unquoted values run to end of line, trimmed. Never touches
+ *  process.env. */
+export declare function parseEnvSource(text: string): ParsedEnvSource;
+/** Single-line, terminal-safe rendering for untrusted display text (names,
+ *  server messages): a string containing terminal-control characters is
+ *  JSON-quoted so it cannot manipulate the terminal; plain strings pass
+ *  through unchanged. "Control" covers C0, DEL, and the C1 range (U+009B is a
+ *  bare CSI) plus the U+2028/U+2029 line separators — and because
+ *  JSON.stringify escapes only C0, the quoted form is post-processed so every
+ *  such character ends up as a \\uXXXX escape. Always applied AFTER
+ *  redaction. */
+export declare function terminalSafe(text: string): string;

package/dist/lib/cli/remote/secretsInput.js

@@ -0,0 +1,123 @@
+// Pure input handling for the remote secrets commands — a sibling of args.ts.
+// No terminal, no `prompts`, no process globals: every environmental input
+// (TTY-ness, stdin, the hidden prompt, the env) arrives injected, so the
+// precedence rules and parsing are testable without a terminal. The concrete
+// adapters live in confirmation.ts.
+/** Where a secret's value comes from, in precedence order: --from-env wins;
+ *  else piped stdin; else the hidden TTY prompt. Never argv. */
+export async function resolveSecretValue(name, sources) {
+    if (sources.fromEnv !== undefined) {
+        const value = sources.env[sources.fromEnv];
+        if (value === undefined || value === "") {
+            return {
+                kind: "error",
+                message: `$${sources.fromEnv} is not set (or is empty) — --from-env needs a non-empty variable.`,
+            };
+        }
+        return { kind: "value", value };
+    }
+    if (!sources.stdinIsTty) {
+        const value = stripOneTrailingNewline(await sources.readStdin());
+        if (value === "") {
+            return {
+                kind: "error",
+                message: "No value on stdin — pipe a non-empty value, or run interactively for a hidden prompt.",
+            };
+        }
+        return { kind: "value", value };
+    }
+    const entered = await sources.promptHidden(name);
+    if (entered === undefined) {
+        return { kind: "canceled" };
+    }
+    if (entered === "") {
+        return { kind: "error", message: "Secret value must not be empty." };
+    }
+    return { kind: "value", value: entered };
+}
+/** One terminal "\r\n" or "\n" removed — exactly one, so a value meant to keep
+ *  a final newline supplies two (printf 'value\n\n'). Interior newlines are
+ *  untouched. */
+export function stripOneTrailingNewline(text) {
+    if (text.endsWith("\r\n")) {
+        return text.slice(0, -2);
+    }
+    if (text.endsWith("\n")) {
+        return text.slice(0, -1);
+    }
+    return text;
+}
+const NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** A small, OWNED dotenv parser. Deliberately not node:util's parseEnv: its
+ *  quoted-value handling differs across Node releases inside the supported
+ *  engine range (22.13.0 mis-splits `B="x=y"` into a bogus extra entry), and
+ *  secret values must parse identically on every supported version. Semantics
+ *  (pinned by tests): `NAME=value` lines; optional `export ` prefix; `#`
+ *  comments and blank lines skipped; single- or double-quoted values may span
+ *  lines and keep `=`/`#` literally; quoted content is LITERAL (no escape
+ *  expansion); unquoted values run to end of line, trimmed. Never touches
+ *  process.env. */
+export function parseEnvSource(text) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const values = new Map();
+    for (let index = 0; index < lines.length; index++) {
+        let line = lines[index].trim();
+        if (line === "" || line.startsWith("#")) {
+            continue;
+        }
+        if (line.startsWith("export ")) {
+            line = line.slice("export ".length).trim();
+        }
+        const equals = line.indexOf("=");
+        if (equals <= 0) {
+            continue;
+        }
+        const name = line.slice(0, equals).trim();
+        if (!NAME_PATTERN.test(name)) {
+            continue;
+        }
+        const rest = line.slice(equals + 1).trim();
+        if (rest.startsWith('"') || rest.startsWith("'")) {
+            const quote = rest[0];
+            let accumulated = rest.slice(1);
+            let closing = accumulated.indexOf(quote);
+            while (closing === -1 && index + 1 < lines.length) {
+                index++;
+                accumulated += `\n${lines[index]}`;
+                closing = accumulated.indexOf(quote);
+            }
+            values.set(name, closing === -1 ? accumulated : accumulated.slice(0, closing));
+        }
+        else {
+            values.set(name, rest);
+        }
+    }
+    return { entries: [...values.entries()].map(([name, value]) => ({ name, value })) };
+}
+/** Single-line, terminal-safe rendering for untrusted display text (names,
+ *  server messages): a string containing terminal-control characters is
+ *  JSON-quoted so it cannot manipulate the terminal; plain strings pass
+ *  through unchanged. "Control" covers C0, DEL, and the C1 range (U+009B is a
+ *  bare CSI) plus the U+2028/U+2029 line separators — and because
+ *  JSON.stringify escapes only C0, the quoted form is post-processed so every
+ *  such character ends up as a \\uXXXX escape. Always applied AFTER
+ *  redaction. */
+export function terminalSafe(text) {
+    if (![...text].some((character) => isTerminalUnsafe(character.codePointAt(0) ?? 0))) {
+        return text;
+    }
+    let escaped = "";
+    for (const character of JSON.stringify(text)) {
+        const code = character.codePointAt(0) ?? 0;
+        escaped += isTerminalUnsafe(code)
+            ? `\\u${code.toString(16).padStart(4, "0")}`
+            : character;
+    }
+    return escaped;
+}
+function isTerminalUnsafe(code) {
+    return (code < 0x20 ||
+        (code >= 0x7f && code <= 0x9f) ||
+        code === 0x2028 ||
+        code === 0x2029);
+}

package/dist/lib/cli/schedule/cron.d.ts

@@ -1,4 +1,5 @@
 export declare const PRESETS: Record<string, string>;
+export declare function canonicalPreset(preset: string): string;
 export declare function presetToCron(preset: string): string;
 export declare function validateCron(expr: string): boolean;
 export declare function resolveCron(opts: {

package/dist/lib/cli/schedule/cron.js

@@ -8,8 +8,22 @@ export const PRESETS = {
     weekly: "0 9 * * 1",
     monthly: "0 9 1 * *",
 };
+// `--every hour` reads better than `--every hourly`, so each preset also
+// accepts its singular noun. Aliases normalize to the canonical name before
+// lookup, storage, and display.
+const PRESET_ALIASES = {
+    hour: "hourly",
+    day: "daily",
+    weekday: "weekdays",
+    weekend: "weekends",
+    week: "weekly",
+    month: "monthly",
+};
+export function canonicalPreset(preset) {
+    return PRESET_ALIASES[preset] ?? preset;
+}
 export function presetToCron(preset) {
-    const cron = PRESETS[preset];
+    const cron = PRESETS[canonicalPreset(preset)];
     if (!cron) {
         throw new Error(`Unknown preset "${preset}". Valid presets: ${Object.keys(PRESETS).join(", ")}`);
     }
@@ -48,7 +62,8 @@ export function validateCron(expr) {
 // --- Resolution ---
 export function resolveCron(opts) {
     if (opts.every) {
-        return { cron: presetToCron(opts.every), preset: opts.every };
+        const preset = canonicalPreset(opts.every);
+        return { cron: presetToCron(preset), preset };
     }
     if (opts.cron) {
         if (!validateCron(opts.cron)) {

package/dist/lib/cli/schedule/remote.d.ts

@@ -0,0 +1,39 @@
+import type { ProjectCommandOptions, RemoteCommandContext } from "../remote/commands/util.js";
+import type { RemoteArgsOptions } from "../remote/args.js";
+import type { CreateScheduleInput, PatchScheduleInput } from "../statelog/schedulesClient.js";
+export type DeployMode = "if-missing" | "always" | "never";
+export type AddRemoteOptions = ProjectCommandOptions & RemoteArgsOptions & {
+    node?: string;
+    function?: string;
+    every?: string;
+    cron?: string;
+    timezone?: string;
+    name?: string;
+    redeploy?: boolean;
+    /** Commander's `--no-deploy` value: `false` when the flag was passed. */
+    deploy?: boolean;
+};
+export type ResolvedScheduleAdd = {
+    input: CreateScheduleInput;
+    deployMode: DeployMode;
+};
+/** Translate `schedule add --backend remote` options into a create request and
+ *  a deployment policy. Pure: every invalid combination throws before any
+ *  target resolution or network work can happen. */
+export declare function resolveScheduleAdd(file: string, options: AddRemoteOptions, defaultTimezone: string): ResolvedScheduleAdd;
+export declare function addRemote(file: string, options: AddRemoteOptions, context: RemoteCommandContext): Promise<void>;
+export type EditRemoteOptions = ProjectCommandOptions & {
+    every?: string;
+    cron?: string;
+    timezone?: string;
+    enabled?: boolean;
+    disabled?: boolean;
+};
+/** Translate edit flags into the server's PATCH body. Only cadence, timezone,
+ *  and enabled are patchable — target, name, and args are immutable on the
+ *  server (delete and re-add to change them). Pure; throws on any invalid or
+ *  empty combination. */
+export declare function resolveSchedulePatch(options: EditRemoteOptions): PatchScheduleInput;
+export declare function listRemote(options: ProjectCommandOptions, context: RemoteCommandContext): Promise<void>;
+export declare function removeRemote(id: string, options: ProjectCommandOptions, context: RemoteCommandContext): Promise<void>;
+export declare function editRemote(id: string, options: EditRemoteOptions, context: RemoteCommandContext): Promise<void>;