@plosson/agentio 0.8.3 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",

package/src/commands/teleport.test.ts

@@ -12,7 +12,7 @@ import {
   type TeleportDeps,
 } from './teleport';
 import type { SiteioRunner, SiteioApp } from '../server/siteio-runner';
-import type { Config } from '../types/config';
+import type { Config, TeleportAppRecord } from '../types/config';
 
 /**
  * Unit tests for `agentio teleport`. Every test injects a fake
@@ -41,6 +41,12 @@ interface FakeRunnerOptions {
   deployedApp?: SiteioApp | null;
   /** Stdout returned by logsApp. Default: empty string. */
   logsStdout?: string;
+  /**
+   * If set, the first call to `deploy` throws an Error with this message;
+   * subsequent calls succeed. Used to simulate siteio rejecting `-f` on
+   * an app that was originally created with `-g` (git mode).
+   */
+  failDeployFirstWith?: string;
   failOn?:
     | 'isInstalled'
     | 'isLoggedIn'
@@ -88,6 +94,14 @@ function makeFakeRunner(opts: FakeRunnerOptions = {}): {
     async deploy(args) {
       calls.push({ method: 'deploy', args });
       if (shouldFail('deploy')) throw new Error('deploy failed');
+      if (opts.failDeployFirstWith != null) {
+        const deployCallCount = calls.filter(
+          (c) => c.method === 'deploy'
+        ).length;
+        if (deployCallCount === 1) {
+          throw new Error(opts.failDeployFirstWith);
+        }
+      }
     },
     async restartApp(name) {
       calls.push({ method: 'restartApp', args: { name } });
@@ -128,6 +142,11 @@ interface FakeDepsOptions extends FakeRunnerOptions {
    * (a healthy 200). Pass [] to simulate an unreachable container.
    */
   healthProbeResponses?: Array<number | null>;
+  /**
+   * The record `getLastTeleportApp` should return. Default: null (no
+   * app remembered yet).
+   */
+  lastTeleportApp?: TeleportAppRecord | null;
 }
 
 interface FakeDeps extends TeleportDeps {
@@ -140,6 +159,8 @@ interface FakeDeps extends TeleportDeps {
   tempFileDeletes: string[];
   healthProbeUrls: string[];
   sleepCalls: number[];
+  /** Records every call to `saveLastTeleportApp`. */
+  savedTeleportApps: TeleportAppRecord[];
 }
 
 function makeDeps(opts: FakeDepsOptions = {}): FakeDeps {
@@ -150,6 +171,7 @@ function makeDeps(opts: FakeDepsOptions = {}): FakeDeps {
   const tempFileDeletes: string[] = [];
   const healthProbeUrls: string[] = [];
   const sleepCalls: number[] = [];
+  const savedTeleportApps: TeleportAppRecord[] = [];
 
   let tempCounter = 0;
   let healthProbeIdx = 0;
@@ -162,6 +184,7 @@ function makeDeps(opts: FakeDepsOptions = {}): FakeDeps {
     tempFileDeletes,
     healthProbeUrls,
     sleepCalls,
+    savedTeleportApps,
     runner,
     loadConfig: async () =>
       ({
@@ -205,6 +228,11 @@ function makeDeps(opts: FakeDepsOptions = {}): FakeDeps {
     sleep: async (ms) => {
       sleepCalls.push(ms);
     },
+    getLastTeleportApp: async () =>
+      'lastTeleportApp' in opts ? (opts.lastTeleportApp ?? null) : null,
+    saveLastTeleportApp: async (record) => {
+      savedTeleportApps.push(record);
+    },
     log: (msg) => logLines.push(msg),
     warn: (msg) => warnLines.push(msg),
   };
@@ -433,6 +461,29 @@ describe('runTeleport — preflight failures', () => {
     // already have their bearer.
     expect(logs).not.toContain('To add to Claude Code:');
   });
+
+  test('rebuild: deploy retries without -f if existing app was created in git mode', async () => {
+    const deps = makeDeps({
+      existingApp: { name: 'mcp', url: 'https://mcp.existing.com' },
+      failDeployFirstWith:
+        'siteio apps deploy mcp -f /tmp/Dockerfile failed (deploy mcp): exit 1\nx Cannot override Dockerfile: app was not created with -f',
+    });
+    const result = await runTeleport({ name: 'mcp' }, deps);
+
+    const deployCalls = deps.calls.filter((c) => c.method === 'deploy');
+    expect(deployCalls).toHaveLength(2);
+    // First attempt passed -f (inline Dockerfile)…
+    expect(
+      (deployCalls[0]!.args as { dockerfilePath?: string }).dockerfilePath
+    ).toMatch(/Dockerfile$/);
+    // …second attempt omits -f so siteio uses its stored git settings.
+    expect(
+      (deployCalls[1]!.args as { dockerfilePath?: string }).dockerfilePath
+    ).toBeUndefined();
+
+    expect(result.serverApiKey).toBe('');
+    expect(deps.logLines.join('\n')).toMatch(/not created with -f/i);
+  });
 });
 
 /* ------------------------------------------------------------------ */
@@ -1483,3 +1534,147 @@ describe('runTeleport — health check on --sync', () => {
     expect(deps.warnLines.join('\n')).toContain('boom');
   });
 });
+
+/* ------------------------------------------------------------------ */
+/* runTeleport — remembered app name                                   */
+/* ------------------------------------------------------------------ */
+
+describe('runTeleport — remembered app name', () => {
+  test('full teleport saves lastApp on success', async () => {
+    const deps = makeDeps();
+    const before = Date.now();
+    await runTeleport({ name: 'mcp' }, deps);
+    const after = Date.now();
+
+    expect(deps.savedTeleportApps).toHaveLength(1);
+    const saved = deps.savedTeleportApps[0]!;
+    expect(saved.name).toBe('mcp');
+    expect(saved.url).toBe('https://mcp.siteio.example.com');
+    expect(saved.deployedAt).toBeGreaterThanOrEqual(before);
+    expect(saved.deployedAt).toBeLessThanOrEqual(after);
+  });
+
+  test('sync saves lastApp on success', async () => {
+    const deps = makeDeps({
+      existingApp: { name: 'mcp', url: 'https://mcp.x.com' },
+      deployedApp: {
+        name: 'mcp',
+        url: 'https://mcp.x.com',
+        volumes: [{ name: 'agentio-data-mcp', mountPath: '/data' }],
+      },
+    });
+    await runTeleport({ name: 'mcp', sync: true }, deps);
+
+    expect(deps.savedTeleportApps).toHaveLength(1);
+    expect(deps.savedTeleportApps[0]!.name).toBe('mcp');
+    expect(deps.savedTeleportApps[0]!.url).toBe('https://mcp.x.com');
+  });
+
+  test('sync without name uses remembered app', async () => {
+    const deps = makeDeps({
+      existingApp: { name: 'mcp', url: 'https://mcp.x.com' },
+      deployedApp: {
+        name: 'mcp',
+        url: 'https://mcp.x.com',
+        volumes: [{ name: 'agentio-data-mcp', mountPath: '/data' }],
+      },
+      lastTeleportApp: {
+        name: 'mcp',
+        url: 'https://mcp.x.com',
+        deployedAt: 1_000_000,
+      },
+    });
+    const result = await runTeleport({ sync: true }, deps);
+    expect(result.name).toBe('mcp');
+    // Confirm it actually reached the siteio calls with the remembered name.
+    const findCall = deps.calls.find((c) => c.method === 'findApp');
+    expect(findCall!.args).toEqual({ name: 'mcp' });
+    // And announced the fallback to the user.
+    expect(deps.logLines.join('\n')).toContain(
+      'Using remembered teleport app "mcp"'
+    );
+  });
+
+  test('sync without name errors if nothing remembered', async () => {
+    const deps = makeDeps({ lastTeleportApp: null });
+    await expect(runTeleport({ sync: true }, deps)).rejects.toThrow(
+      /no remembered teleport app/i
+    );
+    // Did not reach siteio.
+    expect(deps.calls.map((c) => c.method)).not.toContain('findApp');
+  });
+
+  test('full teleport without name uses remembered app', async () => {
+    const deps = makeDeps({
+      lastTeleportApp: {
+        name: 'mcp',
+        url: 'https://mcp.x.com',
+        deployedAt: 1_000_000,
+      },
+    });
+    const result = await runTeleport({}, deps);
+    expect(result.name).toBe('mcp');
+    const createCall = deps.calls.find((c) => c.method === 'createApp');
+    // First time on this fresh runner, no existing app — falls through
+    // to create. The create call must use the remembered name.
+    expect((createCall!.args as { name: string }).name).toBe('mcp');
+  });
+
+  test('explicit name overrides remembered app', async () => {
+    const deps = makeDeps({
+      lastTeleportApp: {
+        name: 'old-app',
+        url: 'https://old.x.com',
+        deployedAt: 1_000_000,
+      },
+    });
+    await runTeleport({ name: 'new-app' }, deps);
+    expect(deps.savedTeleportApps).toHaveLength(1);
+    expect(deps.savedTeleportApps[0]!.name).toBe('new-app');
+    const createCall = deps.calls.find((c) => c.method === 'createApp');
+    expect((createCall!.args as { name: string }).name).toBe('new-app');
+  });
+
+  test('dry-run does NOT save lastApp', async () => {
+    const deps = makeDeps();
+    await runTeleport({ name: 'mcp', dryRun: true }, deps);
+    expect(deps.savedTeleportApps).toHaveLength(0);
+  });
+
+  test('sync dry-run does NOT save lastApp', async () => {
+    const deps = makeDeps({ existingApp: { name: 'mcp' } });
+    await runTeleport(
+      { name: 'mcp', sync: true, dryRun: true },
+      deps
+    );
+    expect(deps.savedTeleportApps).toHaveLength(0);
+  });
+
+  test('failed full teleport (bad health) does NOT save lastApp', async () => {
+    const deps = makeDeps({
+      healthProbeResponses: [],
+      logsStdout: 'crash\n',
+    });
+    await expect(runTeleport({ name: 'mcp' }, deps)).rejects.toThrow(
+      /\/health never returned 200/
+    );
+    expect(deps.savedTeleportApps).toHaveLength(0);
+  });
+
+  test('failed sync (bad health) does NOT save lastApp', async () => {
+    const deps = makeDeps({
+      existingApp: { name: 'mcp', url: 'https://mcp.x.com' },
+      deployedApp: {
+        name: 'mcp',
+        url: 'https://mcp.x.com',
+        volumes: [{ name: 'agentio-data-mcp', mountPath: '/data' }],
+      },
+      healthProbeResponses: [],
+      logsStdout: 'crash\n',
+    });
+    await expect(
+      runTeleport({ name: 'mcp', sync: true }, deps)
+    ).rejects.toThrow(/\/health never returned 200/);
+    expect(deps.savedTeleportApps).toHaveLength(0);
+  });
+});

package/src/commands/teleport.ts

@@ -5,14 +5,14 @@ import { join } from 'path';
 import { tmpdir } from 'os';
 
 import { generateExportData } from './config';
-import { loadConfig } from '../config/config-manager';
+import { loadConfig, saveConfig } from '../config/config-manager';
 import { generateTeleportDockerfile } from '../server/dockerfile-gen';
 import {
   createSiteioRunner,
   type SiteioRunner,
 } from '../server/siteio-runner';
 import { handleError, CliError } from '../utils/errors';
-import type { Config } from '../types/config';
+import type { Config, TeleportAppRecord } from '../types/config';
 
 /**
  * `agentio mcp teleport <name>` — one-command deploy of the local agentio
@@ -141,6 +141,17 @@ export interface TeleportDeps {
   probeHealth: (url: string) => Promise<number | null>;
   /** Resolved after `ms` milliseconds. Injected for testability. */
   sleep: (ms: number) => Promise<void>;
+  /**
+   * Load the most recently teleported app. Used to resolve an
+   * omitted `<name>` argument (e.g. `agentio mcp teleport --sync`).
+   * Returns null if nothing has been remembered yet.
+   */
+  getLastTeleportApp: () => Promise<TeleportAppRecord | null>;
+  /**
+   * Persist the most recently teleported app so future invocations
+   * without a `<name>` can default to it.
+   */
+  saveLastTeleportApp: (record: TeleportAppRecord) => Promise<void>;
   log: (msg: string) => void;
   warn: (msg: string) => void;
 }
@@ -187,7 +198,12 @@ export async function waitForHealth(
 }
 
 export interface TeleportOptions {
-  name: string;
+  /**
+   * Siteio app name. Optional: if omitted, `runTeleport` will fall
+   * back to the most recently teleported app recorded in config
+   * (`config.teleport.lastApp`). Required for the very first deploy.
+   */
+  name?: string;
   dockerfileOnly?: boolean;
   output?: string;
   dryRun?: boolean;
@@ -227,6 +243,32 @@ export interface TeleportResult {
   claudeMcpAddCommand: string | null;
 }
 
+/**
+ * Resolve the siteio app name, falling back to the remembered one if
+ * the caller omitted `<name>`. Validates the resulting name. Throws a
+ * user-facing CliError if nothing is provided and nothing is remembered.
+ */
+async function resolveAppName(
+  requested: string | undefined,
+  deps: TeleportDeps
+): Promise<string> {
+  if (requested) {
+    validateAppName(requested);
+    return requested;
+  }
+  const last = await deps.getLastTeleportApp();
+  if (!last) {
+    throw new CliError(
+      'INVALID_PARAMS',
+      'No app name provided and no remembered teleport app',
+      'Pass <name> explicitly the first time, e.g. `agentio mcp teleport mcp`. The name is remembered after the first successful deploy.'
+    );
+  }
+  validateAppName(last.name);
+  deps.log(`Using remembered teleport app "${last.name}".`);
+  return last.name;
+}
+
 /**
  * Sync mode: re-export local config and push it to an existing siteio
  * app, then restart. Same dependency-injection model as runTeleport
@@ -236,6 +278,7 @@ async function runSync(
   opts: TeleportOptions,
   deps: TeleportDeps
 ): Promise<TeleportResult> {
+  const name = await resolveAppName(opts.name, deps);
   // Preflight: same as full teleport.
   deps.log('Checking siteio…');
   if (!(await deps.runner.isInstalled())) {
@@ -268,13 +311,13 @@ async function runSync(
 
   // Sync requires the app to ALREADY EXIST. This is the inverse of the
   // normal teleport check.
-  deps.log(`Checking that siteio app "${opts.name}" exists…`);
-  const existing = await deps.runner.findApp(opts.name);
+  deps.log(`Checking that siteio app "${name}" exists…`);
+  const existing = await deps.runner.findApp(name);
   if (!existing) {
     throw new CliError(
       'NOT_FOUND',
-      `No siteio app named "${opts.name}" to sync to`,
-      `Run \`agentio mcp teleport ${opts.name}\` (without --sync) first to create it.`
+      `No siteio app named "${name}" to sync to`,
+      `Run \`agentio mcp teleport ${name}\` (without --sync) first to create it.`
     );
   }
 
@@ -285,11 +328,11 @@ async function runSync(
   // Detect whether /data is already mounted as a persistent volume.
   // If not, attach it as part of this sync (one-time backfill for apps
   // teleported before the volume was a default).
-  const detail = await deps.runner.appInfo(opts.name);
+  const detail = await deps.runner.appInfo(name);
   const needsVolumeBackfill = !hasDataVolumeMount(detail);
   if (needsVolumeBackfill) {
     deps.log(
-      `No persistent volume mounted at ${DATA_VOLUME_PATH} — will attach ${volumeNameFor(opts.name)}:${DATA_VOLUME_PATH} as part of this sync.`
+      `No persistent volume mounted at ${DATA_VOLUME_PATH} — will attach ${volumeNameFor(name)}:${DATA_VOLUME_PATH} as part of this sync.`
     );
   }
 
@@ -297,22 +340,22 @@ async function runSync(
   if (opts.dryRun) {
     deps.log('--- Dry run: the following commands would be executed ---');
     const dryParts = [
-      `siteio apps set ${opts.name}`,
+      `siteio apps set ${name}`,
       '-e AGENTIO_KEY=<redacted>',
       `-e AGENTIO_CONFIG=<${exported.config.length} chars>`,
     ];
     if (needsVolumeBackfill) {
       dryParts.push(
-        `-v ${volumeNameFor(opts.name)}:${DATA_VOLUME_PATH}`
+        `-v ${volumeNameFor(name)}:${DATA_VOLUME_PATH}`
       );
     }
     deps.log(dryParts.join(' '));
-    deps.log(`siteio apps restart ${opts.name}`);
+    deps.log(`siteio apps restart ${name}`);
     deps.log(
       '(AGENTIO_SERVER_API_KEY is intentionally NOT touched — operator key on the remote stays the same.)'
     );
     return {
-      name: opts.name,
+      name: name,
       serverApiKey: '',
       claudeMcpAddCommand: null,
     };
@@ -333,20 +376,20 @@ async function runSync(
   // REPLACES the volumes list on update (env merges; volumes don't),
   // so attaching when something else is mounted would clobber it.
   await deps.runner.setApp({
-    name: opts.name,
+    name: name,
     envVars: {
       AGENTIO_KEY: exported.key,
       AGENTIO_CONFIG: exported.config,
     },
     ...(needsVolumeBackfill
       ? {
-          volumes: { [volumeNameFor(opts.name)]: DATA_VOLUME_PATH },
+          volumes: { [volumeNameFor(name)]: DATA_VOLUME_PATH },
         }
       : {}),
   });
 
   deps.log('Restarting container so the new env vars take effect…');
-  await deps.runner.restartApp(opts.name);
+  await deps.runner.restartApp(name);
 
   // We already fetched appInfo earlier for volume detection; reuse
   // its URL field rather than calling again. Same fallback as the
@@ -354,7 +397,7 @@ async function runSync(
   // generated subdomain URL, so fall back to findApp if it's missing.
   let url = typeof detail?.url === 'string' ? detail.url : undefined;
   if (!url) {
-    const listed = await deps.runner.findApp(opts.name);
+    const listed = await deps.runner.findApp(name);
     if (typeof listed?.url === 'string') url = listed.url;
   }
 
@@ -368,7 +411,7 @@ async function runSync(
       deps.warn(
         `Container failed to report healthy after ${Math.round(HEALTH_TIMEOUT_MS / 1000)}s. Fetching logs…`
       );
-      const logs = await deps.runner.logsApp(opts.name, {
+      const logs = await deps.runner.logsApp(name, {
         tail: HEALTH_FAILURE_LOG_TAIL,
       });
       deps.warn('--- container logs (tail) ---');
@@ -376,12 +419,21 @@ async function runSync(
       deps.warn('--- end logs ---');
       throw new CliError(
         'API_ERROR',
-        `Sync to "${opts.name}" restarted the container but /health never returned 200`,
+        `Sync to "${name}" restarted the container but /health never returned 200`,
         'Inspect the logs above. The previous config is gone — the next sync (or a manual `siteio apps restart`) will still see the broken state until you fix the root cause.'
       );
     }
   }
 
+  // Remember the app so a future bare `--sync` (or any name-less
+  // teleport invocation) can default to it. Only reached once the
+  // restart + health check have both succeeded.
+  await deps.saveLastTeleportApp({
+    name,
+    url,
+    deployedAt: Date.now(),
+  });
+
   deps.log('');
   deps.log('Sync complete!');
   if (url) {
@@ -408,7 +460,7 @@ async function runSync(
   }
 
   return {
-    name: opts.name,
+    name: name,
     url,
     // We did not generate a new server key in sync mode.
     serverApiKey: '',
@@ -424,8 +476,6 @@ export async function runTeleport(
   opts: TeleportOptions,
   deps: TeleportDeps
 ): Promise<TeleportResult> {
-  validateAppName(opts.name);
-
   // Sync mode short-circuits — different command shape, different
   // preflight (app must EXIST, not absent), no Dockerfile work, no
   // create. Mutual exclusion with the "create new app" flags.
@@ -461,6 +511,11 @@ export async function runTeleport(
     return runSync(opts, deps);
   }
 
+  // Resolve the app name up front so every downstream path (including
+  // dockerfile-only and dry-run) uses a single consistent value, and
+  // so an omitted name cleanly falls back to the remembered app.
+  const name = await resolveAppName(opts.name, deps);
+
   // dockerfile-only: skip every siteio interaction, just emit the
   // Dockerfile to stdout or a file and return.
   if (opts.dockerfileOnly) {
@@ -476,7 +531,7 @@ export async function runTeleport(
       process.stdout.write(content);
     }
     return {
-      name: opts.name,
+      name: name,
       serverApiKey: '',
       claudeMcpAddCommand: null,
     };
@@ -519,16 +574,16 @@ export async function runTeleport(
   // and their issued bearers), backfill /data if needed, and redeploy
   // the freshly generated image. If it doesn't exist, fall through to
   // the fresh-deploy path.
-  deps.log(`Checking if siteio app "${opts.name}" already exists…`);
-  const existing = await deps.runner.findApp(opts.name);
+  deps.log(`Checking if siteio app "${name}" already exists…`);
+  const existing = await deps.runner.findApp(name);
   const isRebuild = Boolean(existing);
   if (isRebuild) {
     deps.log(
-      `Found existing siteio app "${opts.name}" — will rebuild image in place (API key and clients preserved).`
+      `Found existing siteio app "${name}" — will rebuild image in place (API key and clients preserved).`
     );
   } else {
     deps.log(
-      `No existing siteio app "${opts.name}" — will create a fresh one.`
+      `No existing siteio app "${name}" — will create a fresh one.`
     );
   }
 
@@ -550,11 +605,11 @@ export async function runTeleport(
   // the persistent volume if it's missing (same logic as --sync).
   let needsVolumeBackfill = false;
   if (isRebuild) {
-    const detail = await deps.runner.appInfo(opts.name);
+    const detail = await deps.runner.appInfo(name);
     needsVolumeBackfill = !hasDataVolumeMount(detail);
     if (needsVolumeBackfill) {
       deps.log(
-        `No persistent volume mounted at ${DATA_VOLUME_PATH} — will attach ${volumeNameFor(opts.name)}:${DATA_VOLUME_PATH} as part of this rebuild.`
+        `No persistent volume mounted at ${DATA_VOLUME_PATH} — will attach ${volumeNameFor(name)}:${DATA_VOLUME_PATH} as part of this rebuild.`
       );
     }
   }
@@ -590,16 +645,16 @@ export async function runTeleport(
     if (!isRebuild) {
       if (gitSettings) {
         deps.log(
-          `siteio apps create ${opts.name} -g ${gitSettings.repoUrl} --branch ${gitSettings.branch} --dockerfile ${TELEPORT_DOCKERFILE_PATH} -p 9999`
+          `siteio apps create ${name} -g ${gitSettings.repoUrl} --branch ${gitSettings.branch} --dockerfile ${TELEPORT_DOCKERFILE_PATH} -p 9999`
         );
       } else {
         deps.log(
-          `siteio apps create ${opts.name} -f <tempfile> -p 9999`
+          `siteio apps create ${name} -f <tempfile> -p 9999`
         );
       }
     }
     const setParts = [
-      `siteio apps set ${opts.name}`,
+      `siteio apps set ${name}`,
       '-e AGENTIO_KEY=<redacted>',
       `-e AGENTIO_CONFIG=<${exported.config.length} chars>`,
     ];
@@ -607,11 +662,11 @@ export async function runTeleport(
       setParts.push(`-e AGENTIO_SERVER_API_KEY=${serverApiKey}`);
     }
     if (!isRebuild || needsVolumeBackfill) {
-      setParts.push(`-v ${volumeNameFor(opts.name)}:${DATA_VOLUME_PATH}`);
+      setParts.push(`-v ${volumeNameFor(name)}:${DATA_VOLUME_PATH}`);
     }
     deps.log(setParts.join(' '));
     deps.log(
-      `siteio apps deploy ${opts.name}${opts.noCache ? ' --no-cache' : ''}`
+      `siteio apps deploy ${name}${opts.noCache ? ' --no-cache' : ''}`
     );
     if (isRebuild) {
       deps.log(
@@ -628,7 +683,7 @@ export async function runTeleport(
       );
     }
     return {
-      name: opts.name,
+      name: name,
       serverApiKey,
       claudeMcpAddCommand: null,
     };
@@ -643,10 +698,10 @@ export async function runTeleport(
 
   try {
     if (!isRebuild) {
-      deps.log(`Creating siteio app "${opts.name}"…`);
+      deps.log(`Creating siteio app "${name}"…`);
       if (gitSettings) {
         await deps.runner.createApp({
-          name: opts.name,
+          name: name,
           port: 9999,
           git: {
             repoUrl: gitSettings.repoUrl,
@@ -656,7 +711,7 @@ export async function runTeleport(
         });
       } else {
         await deps.runner.createApp({
-          name: opts.name,
+          name: name,
           dockerfilePath: tempPath!,
           port: 9999,
         });
@@ -686,10 +741,10 @@ export async function runTeleport(
     }
 
     await deps.runner.setApp({
-      name: opts.name,
+      name: name,
       envVars,
       ...(attachVolume
-        ? { volumes: { [volumeNameFor(opts.name)]: DATA_VOLUME_PATH } }
+        ? { volumes: { [volumeNameFor(name)]: DATA_VOLUME_PATH } }
         : {}),
     });
 
@@ -698,17 +753,39 @@ export async function runTeleport(
         ? 'Rebuilding (this may take a minute — Docker is rebuilding your image)…'
         : 'Deploying (this may take a minute — Docker is building your image)…'
     );
-    await deps.runner.deploy({
-      name: opts.name,
-      // In git mode, there's no -f to re-pass on deploy — siteio uses
-      // the stored git settings from create.
-      ...(tempPath ? { dockerfilePath: tempPath } : {}),
-      noCache: opts.noCache,
-    });
+    try {
+      await deps.runner.deploy({
+        name: name,
+        // In git mode, there's no -f to re-pass on deploy — siteio uses
+        // the stored git settings from create.
+        ...(tempPath ? { dockerfilePath: tempPath } : {}),
+        noCache: opts.noCache,
+      });
+    } catch (err) {
+      // The existing app may have been created in git mode (no -f). siteio
+      // refuses `deploy -f` in that case with a specific error — retry
+      // without -f so it falls back to the stored git settings.
+      if (
+        isRebuild &&
+        tempPath &&
+        err instanceof Error &&
+        /not created with -f/i.test(err.message)
+      ) {
+        deps.log(
+          'Existing app was not created with -f — retrying deploy without inline Dockerfile (siteio will rebuild from its stored git settings).'
+        );
+        await deps.runner.deploy({
+          name: name,
+          noCache: opts.noCache,
+        });
+      } else {
+        throw err;
+      }
+    }
 
     // Try to surface the deployed URL. Non-fatal if siteio doesn't
     // give us one back.
-    const info = await deps.runner.appInfo(opts.name);
+    const info = await deps.runner.appInfo(name);
     let url = typeof info?.url === 'string' ? info.url : undefined;
     // siteio's `apps info --json` output omits the generated subdomain
     // URL (domains: [] in the payload) even though the app is reachable
@@ -716,7 +793,7 @@ export async function runTeleport(
     // level. Fall back to findApp so the post-deploy health check can
     // still run even when siteio doesn't surface url in info.
     if (!url) {
-      const listed = await deps.runner.findApp(opts.name);
+      const listed = await deps.runner.findApp(name);
       if (typeof listed?.url === 'string') url = listed.url;
     }
 
@@ -731,7 +808,7 @@ export async function runTeleport(
         deps.warn(
           `Container failed to report healthy after ${Math.round(HEALTH_TIMEOUT_MS / 1000)}s. Fetching logs…`
         );
-        const logs = await deps.runner.logsApp(opts.name, {
+        const logs = await deps.runner.logsApp(name, {
           tail: HEALTH_FAILURE_LOG_TAIL,
         });
         deps.warn('--- container logs (tail) ---');
@@ -739,14 +816,14 @@ export async function runTeleport(
         deps.warn('--- end logs ---');
         throw new CliError(
           'API_ERROR',
-          `Deploy "${opts.name}" started but /health never returned 200`,
+          `Deploy "${name}" started but /health never returned 200`,
           'Inspect the logs above. Common causes: permission errors on mounted volumes, missing env vars, binary not found for the container arch.'
         );
       }
     } else {
       deps.warn(
         'Skipping health check: siteio did not return a URL for this app. ' +
-          `Run \`siteio apps info ${opts.name}\` and curl <url>/health manually to verify.`
+          `Run \`siteio apps info ${name}\` and curl <url>/health manually to verify.`
       );
     }
 
@@ -754,6 +831,15 @@ export async function runTeleport(
       ? `claude mcp add --scope local --transport http agentio "${url}/mcp?services=rss"`
       : null;
 
+    // Remember the app so a future bare `--sync` (or any name-less
+    // teleport invocation) can default to it. Only reached once the
+    // deploy + health check have both succeeded.
+    await deps.saveLastTeleportApp({
+      name,
+      url,
+      deployedAt: Date.now(),
+    });
+
     deps.log('');
     deps.log(isRebuild ? 'Rebuild complete!' : 'Teleport complete!');
     if (url) {
@@ -762,7 +848,7 @@ export async function runTeleport(
       deps.log(`  MCP:       ${url}/mcp`);
     } else {
       deps.log(
-        `  URL:       (siteio did not return a URL — run \`siteio apps info ${opts.name}\` to look it up)`
+        `  URL:       (siteio did not return a URL — run \`siteio apps info ${name}\` to look it up)`
       );
     }
     if (isRebuild) {
@@ -781,7 +867,7 @@ export async function runTeleport(
     }
 
     return {
-      name: opts.name,
+      name: name,
       url,
       serverApiKey,
       claudeMcpAddCommand: claudeCmd,
@@ -847,6 +933,29 @@ async function defaultSleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * Default `getLastTeleportApp`: read `config.teleport.lastApp` from
+ * `~/.config/agentio/config.json`. Returns null if the config has no
+ * teleport memory yet.
+ */
+async function defaultGetLastTeleportApp(): Promise<TeleportAppRecord | null> {
+  const config = (await loadConfig()) as Config;
+  return config.teleport?.lastApp ?? null;
+}
+
+/**
+ * Default `saveLastTeleportApp`: merge into `config.teleport.lastApp`
+ * and persist. Single-slot — the most recent successful teleport
+ * overwrites whatever was there before.
+ */
+async function defaultSaveLastTeleportApp(
+  record: TeleportAppRecord
+): Promise<void> {
+  const config = (await loadConfig()) as Config;
+  config.teleport = { ...(config.teleport ?? {}), lastApp: record };
+  await saveConfig(config);
+}
+
 async function defaultDetectGitOriginUrl(): Promise<string | null> {
   try {
     const proc = Bun.spawn(['git', 'remote', 'get-url', 'origin'], {
@@ -877,8 +986,8 @@ export function registerTeleportCommand(parent: Command): void {
       'Deploy the agentio HTTP MCP server to a siteio-managed remote in one command'
     )
     .argument(
-      '<name>',
-      'Siteio app name (becomes the subdomain: e.g. "mcp" → mcp.<your-siteio-domain>)'
+      '[name]',
+      'Siteio app name (becomes the subdomain: e.g. "mcp" → mcp.<your-siteio-domain>). Optional on subsequent runs — defaults to the most recently deployed app.'
     )
     .option(
       '--dockerfile-only',
@@ -908,7 +1017,7 @@ export function registerTeleportCommand(parent: Command): void {
       '--sync',
       'Push the latest local config (profiles + credentials) to an EXISTING siteio app and restart it. Use after adding/changing a profile. Does not rebuild the image; does not change the operator API key.'
     )
-    .action(async (name: string, options) => {
+    .action(async (name: string | undefined, options) => {
       try {
         const runner = createSiteioRunner();
         await runTeleport(
@@ -937,6 +1046,8 @@ export function registerTeleportCommand(parent: Command): void {
             detectGitOriginUrl: defaultDetectGitOriginUrl,
             probeHealth: defaultProbeHealth,
             sleep: defaultSleep,
+            getLastTeleportApp: defaultGetLastTeleportApp,
+            saveLastTeleportApp: defaultSaveLastTeleportApp,
             log: (msg) => console.log(msg),
             warn: (msg) => console.error(msg),
           }

package/src/server/favicon.ts

@@ -0,0 +1,17 @@
+/**
+ * Embedded favicon served at `/favicon.ico` and `/favicon.png`. Keeps MCP
+ * clients (e.g. Claude's connector UI) from falling back to the generic
+ * globe icon. Bytes are inlined so every build target — dev, `bun build
+ * --target node`, and `bun build --compile` — ships it without filesystem
+ * lookups.
+ *
+ * Source: `site/logo.png` (120x120 PNG).
+ */
+
+const FAVICON_BASE64 =
+  'iVBORw0KGgoAAAANSUhEUgAAAHgAAAB4EAIAAADmln3GAAAAIGNIUk0AAHomAACAhAAA+gAAAIDoAAB1MAAA6mAAADqYAAAXcJy6UTwAAAAGYktHRP///////wlY99wAAAAHdElNRQfqAQMQAyhWYExTAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDI2LTAxLTAzVDE2OjAzOjM5KzAwOjAwTY3PQAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAyNi0wMS0wM1QxNjowMzozOSswMDowMDzQd/wAAAAodEVYdGRhdGU6dGltZXN0YW1wADIwMjYtMDEtMDNUMTY6MDM6MzkrMDA6MDBrxVYjAAAMjklEQVR42u3dd1QU1x4H8Dtll04EREBFEBSVIiWCFAUBsccSTYyFGKOIPp9HeXmWYIklqKioiSHRaKIGsSTHEiNRH6iRpgRDsUSKiGIE9IkNZZfdnZn3x7z3Ts5LZnbdyt73+/zlcX87d+71e2an3DsScXFpaS9eIACwQJp6BwDQJwg0wAoEGmAFAg2wAoEGWIFAA6xAoAFWINAAKxBogBUINMAKBBpgBQINsAKBBliBQAOsQKABViDQACsQaIAVCDTACgQaYAUCDbACgQZYgUADrECgAVYg0AArEGiAFQg0wAoEGmAFAg2wAoEGWIFAA6xAoAFWINAAKxBogBUINMAKBBpgBQINsAKBBliBQAOsQKABViDQACsQaIAVCDTACgQaYAUCDbACgQZYgUADrECgAVYg0AArEGiAFQg0wAoEGmAFAg2w8i9H6natiosOZAAAAABJRU5ErkJggg==';
+
+export const FAVICON_BYTES = Uint8Array.from(
+  Buffer.from(FAVICON_BASE64, 'base64')
+);
+export const FAVICON_CONTENT_TYPE = 'image/png';

package/src/server/http.ts

@@ -2,6 +2,7 @@ import { handleMcpRequest } from './mcp-http';
 import type { OAuthStore } from './oauth-store';
 import { requireBearer, routeOAuth } from './oauth';
 import { routeSetup } from './setup-page';
+import { FAVICON_BYTES, FAVICON_CONTENT_TYPE } from './favicon';
 
 /**
  * Context passed to every fetch handler invocation. Built once at boot in
@@ -36,6 +37,16 @@ export async function handleRequest(
     return jsonResponse({ ok: true });
   }
 
+  if (url.pathname === '/favicon.ico' || url.pathname === '/favicon.png') {
+    return new Response(FAVICON_BYTES, {
+      status: 200,
+      headers: {
+        'content-type': FAVICON_CONTENT_TYPE,
+        'cache-control': 'public, max-age=86400',
+      },
+    });
+  }
+
   // Root setup page — operator-facing UI (API-key gated) for picking
   // profiles and generating the MCP URL.
   const setupResponse = await routeSetup(req, ctx);

package/src/server/setup-page.ts

@@ -188,6 +188,7 @@ function loginFormHtml(errorMessage?: string): string {
 <html lang="en">
 <head>
 <meta charset="utf-8">
+<link rel="icon" type="image/png" href="/favicon.png">
 <title>agentio MCP setup</title>
 <style>${BASE_CSS}</style>
 </head>
@@ -307,6 +308,7 @@ ${sectionsHtml}
 <html lang="en">
 <head>
 <meta charset="utf-8">
+<link rel="icon" type="image/png" href="/favicon.png">
 <title>agentio MCP setup</title>
 <style>${BASE_CSS}${PROFILES_CSS}</style>
 </head>

package/src/types/config.ts

@@ -40,6 +40,23 @@ export interface ProfileEntry {
 // Helper type for backward compatibility during migration
 export type ProfileValue = string | ProfileEntry;
 
+/**
+ * Record of a successfully teleported siteio app. Persisted so that
+ * `agentio mcp teleport --sync` (and other name-optional variants) can
+ * default to the most recently deployed app instead of forcing the
+ * user to re-type the name every time.
+ */
+export interface TeleportAppRecord {
+  name: string;
+  url?: string;
+  /** Unix epoch milliseconds of the last successful deploy or sync. */
+  deployedAt: number;
+}
+
+export interface TeleportConfig {
+  lastApp?: TeleportAppRecord;
+}
+
 export interface Config {
   profiles: {
     gdocs?: ProfileValue[];
@@ -60,6 +77,7 @@ export interface Config {
   env?: Record<string, string>;
   gateway?: GatewayConfig;
   server?: ServerConfig;
+  teleport?: TeleportConfig;
 }
 
 export type ServiceName = 'gdocs' | 'gdrive' | 'gmail' | 'gcal' | 'gtasks' | 'gchat' | 'gsheets' | 'github' | 'jira' | 'slack' | 'telegram' | 'whatsapp' | 'discourse' | 'sql';