@phnx-labs/agents-cli 1.22.34 → 1.22.37

package/dist/commands/setup-share.js

@@ -8,7 +8,7 @@
  */
 import chalk from 'chalk';
 import { DEFAULT_BUCKET_NAME, DEFAULT_CF_BUNDLE, DEFAULT_WORKER_NAME, readShareConfig, } from '../lib/share/config.js';
-import { runShareProvision, runShareJoin } from './share.js';
+import { runShareProvision, runShareJoin, runShareUpdate, shareTemplateStatus } from './share.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 /**
  * Interactive share setup. Returns true if the user configured (or already had)
@@ -25,12 +25,42 @@ export async function runShareWizard() {
     if (existing) {
         console.log(chalk.dim(`Share is already configured → ${chalk.green(existing.baseUrl)}`));
         console.log(chalk.dim(`  worker ${existing.workerName} · bucket ${existing.bucketName} · account ${existing.accountId}`));
-        const { confirm } = await import('@inquirer/prompts');
-        const reconfigure = await confirm({ message: 'Reconfigure the share endpoint?', default: false });
-        if (!reconfigure) {
+        const templateStatus = shareTemplateStatus(existing);
+        console.log(chalk.dim(`  template ${templateStatus}`));
+        const { select } = await import('@inquirer/prompts');
+        const action = await select({
+            message: 'Share is already configured. What do you want to do?',
+            choices: [
+                { name: 'Keep as is', value: 'keep' },
+                {
+                    name: 'Update the deployed Worker to the latest template',
+                    value: 'update',
+                    description: templateStatus === 'current'
+                        ? 'Already current — this re-deploys anyway and refreshes the token in place.'
+                        : 'Re-deploys the Worker script on your existing endpoint (same account/worker/bucket, same write token).',
+                },
+                {
+                    name: 'Reconfigure from scratch (provision or join again)',
+                    value: 'reconfigure',
+                },
+            ],
+            default: templateStatus === 'outdated' || templateStatus === 'unknown' ? 'update' : 'keep',
+        });
+        if (action === 'keep') {
             console.log(chalk.dim('Keeping the current endpoint.'));
             return true;
         }
+        if (action === 'update') {
+            // When the template is already current, the description below promises a
+            // re-deploy anyway — force it, or runShareUpdate's own no-op would silently
+            // contradict what was just said.
+            const result = await runShareUpdate({ force: templateStatus === 'current' });
+            console.log(result.updated
+                ? chalk.green(`Worker '${result.workerName}' updated → template ${result.templateHash.slice(0, 12)}…`)
+                : chalk.dim(`Worker '${result.workerName}' already matches the current template — no-op.`));
+            return true;
+        }
+        // action === 'reconfigure' — fall through to the provision/join flow below.
     }
     const { select } = await import('@inquirer/prompts');
     const mode = await select({

package/dist/commands/setup.d.ts

@@ -10,6 +10,11 @@ interface RunSetupOptions {
     suppressFooter?: boolean;
     systemRepo?: boolean;
     runHub?: () => Promise<void>;
+    startDaemonFn?: () => {
+        pid: number | null;
+        method: string;
+    };
+    isDaemonEnabledFn?: () => boolean;
 }
 /** First-run setup. Clones ~/.agents/.system/ from the system repo if needed. */
 export declare function runSetup(program: Command, options?: RunSetupOptions): Promise<void>;

package/dist/commands/setup.js

@@ -131,6 +131,20 @@ export async function runSetup(program, options = {}) {
             spinner.succeed(`Cloned ${systemRepoSlug(systemRepo)} (${result.commit})`);
         }
     }
+    try {
+        const enabled = options.isDaemonEnabledFn
+            ? options.isDaemonEnabledFn()
+            : (await import('../lib/device-config.js')).isDaemonEnabled();
+        if (enabled) {
+            const start = options.startDaemonFn
+                ?? (await import('../lib/daemon.js')).startDaemon;
+            const started = start();
+            if (started.method !== 'already-running' && started.pid) {
+                console.log(chalk.gray(`Started the always-on agents daemon (pid ${started.pid}).`));
+            }
+        }
+    }
+    catch { /* best effort */ }
     // Populate the device registry from the tailnet on first setup. Soft mode is
     // guaranteed non-throwing (no tailscale / corrupt file / lock contention all
     // resolve to ok:false), so this can never block setup.
@@ -195,6 +209,18 @@ export async function runSetup(program, options = {}) {
             }
         }
     }
+    // Register the agents:// URL scheme so deep links in rendered artifacts can
+    // resume a session (RUSH — session deep links). Best-effort and idempotent:
+    // never fails setup, only registers when missing.
+    try {
+        const { registerAgentsUrlScheme } = await import('../lib/deeplink/register.js');
+        const scheme = registerAgentsUrlScheme({ ifMissing: true });
+        if (scheme.registered)
+            console.log(chalk.gray('Registered the agents:// URL scheme (artifact session deep links).'));
+    }
+    catch {
+        // non-fatal — the user can run `agents open register` later.
+    }
     if (options.suppressFooter)
         return;
     // Fresh-machine hub: offer to set up the optional capabilities that need their

package/dist/commands/share.d.ts

@@ -1,7 +1,71 @@
 import type { Command } from 'commander';
+import { type ShareConfig } from '../lib/share/config.js';
 import { type CloudflareRequester } from '../lib/share/provision.js';
 import { type PublishResult } from '../lib/share/publish.js';
+import { deleteShare, type DeleteShareResult } from '../lib/share/delete.js';
 export declare function formatSharePublishResult(result: PublishResult, json?: boolean): string;
+/** Compare the configured endpoint's last-deployed template hash against the
+ * hash of the CURRENT `worker-template.ts` render. A config with no recorded
+ * hash (every endpoint provisioned before this field existed) is "unknown" —
+ * never "current" or "outdated", since there is nothing to compare against. */
+export declare function shareTemplateStatus(cfg: ShareConfig): 'current' | 'outdated' | 'unknown';
+/** One published object as reported by the Worker's `?format=json` listing route. */
+export interface ShareListItem {
+    slug: string;
+    url: string;
+    /** Object size in bytes. */
+    size: number;
+    /** Stored content type, or null if the Worker had none recorded. */
+    contentType: string | null;
+    /** ISO timestamp the object was last written (R2 `uploaded`). */
+    publishedAt: string;
+    /** ISO auto-expire timestamp, or null for a permanent share. */
+    expiresAt: string | null;
+}
+export interface ShareListResult {
+    /** The namespace listed. */
+    user: string;
+    count: number;
+    objects: ShareListItem[];
+}
+/** DI seam for tests — override the real HTTP GET of the JSON listing route. */
+export type ListingFetchFn = (url: string) => Promise<{
+    status: number;
+    contentType: string;
+    body: string;
+}>;
+/** Parse the Worker's listing JSON into a validated result, failing loud (with the
+ * outdated-template hint) on any body that isn't the expected shape — an old Worker
+ * serves the HTML gallery for a non-empty namespace, which must not be silently
+ * accepted as "you have published nothing". */
+export declare function parseShareListing(user: string, body: string): ShareListResult;
+/** Fetch and parse the machine-readable listing of the caller's namespace from the
+ * Worker's `?format=json` route. Fails loud when share was never configured, when
+ * the deployed template is known-outdated (RUSH-2449 templateHash), or when the
+ * live response proves the route is absent (404 or a non-JSON 200 = the old HTML
+ * gallery) — never a silent empty/wrong result. */
+export declare function runShareList(opts?: {
+    githubUser?: string;
+    config?: ShareConfig;
+    fetchListing?: ListingFetchFn;
+}): Promise<ShareListResult>;
+export declare function formatShareList(result: ShareListResult, json?: boolean): string;
+export declare function formatShareDeleteResult(result: DeleteShareResult, json?: boolean): string;
+interface ShareDeleteCliOpts {
+    keepCover?: boolean;
+    ifExists?: boolean;
+    githubUser?: string;
+    json?: boolean;
+}
+/** Shared handler for `agents share delete <targets...>` and the top-level
+ * `agents unshare <targets...>` alias. Deletes each target independently and
+ * continues past a failed one (rm-style), reporting all results and exiting
+ * non-zero if any target failed to verify as gone.
+ *
+ * `deleteFn` is a DI seam for tests (defaults to the real `deleteShare`) — it is
+ * never exposed as a CLI flag, only used to inject a fake config/checker/deleter
+ * without touching the keychain or a live endpoint. */
+export declare function runShareDelete(targets: string[], opts: ShareDeleteCliOpts, deleteFn?: typeof deleteShare): Promise<void>;
 export declare function registerShareCommands(program: Command): void;
 /** Provision a fresh R2 bucket + Worker on the user's Cloudflare and persist the
  * endpoint config + write token. Shared by `agents share setup` and the unified
@@ -16,9 +80,30 @@ export declare function runShareProvision(opts: {
     analyticsToken?: string;
     request?: CloudflareRequester;
 }): Promise<void>;
+export interface ShareUpdateResult {
+    updated: boolean;
+    templateHash: string;
+    baseUrl: string;
+    workerName: string;
+}
+/** Re-deploy the Worker script on an ALREADY-provisioned endpoint to match the
+ * current `worker-template.ts`. Reuses the existing account/worker/bucket and
+ * write token from `readShareConfig()`/the `share` bundle — never creates a
+ * bucket, touches routes/domains, or regenerates the token (see
+ * `updateWorker` in `lib/share/provision.ts` for how the token survives the
+ * re-upload). Idempotent: no-ops when the deployed hash already matches
+ * unless `force`. */
+export declare function runShareUpdate(opts?: {
+    bundle?: string;
+    account?: string;
+    token?: string;
+    force?: boolean;
+    request?: CloudflareRequester;
+}): Promise<ShareUpdateResult>;
 /** Join an existing share endpoint (no provisioning): prompt for the endpoint
  * details + write token and persist them. Shared by `agents share join` and the
  * unified `agents setup share` wizard. */
 export declare function runShareJoin(baseUrl?: string, opts?: {
     token?: string;
 }): Promise<void>;
+export {};