gipity 1.0.409 → 1.0.410

package/dist/claude-setup.js

@@ -24,7 +24,7 @@ export function claudeInstallPlan(platformOverride) {
 /** Whether the `claude` binary resolves on PATH. */
 export function isClaudeInstalled(platformOverride) {
     try {
-        execSync(claudeInstallPlan(platformOverride).checkCmd, { stdio: 'ignore' });
+        execSync(claudeInstallPlan(platformOverride).checkCmd, { stdio: 'ignore', windowsHide: true });
         return true;
     }
     catch {
@@ -59,6 +59,7 @@ export function probeClaudeAuthenticated() {
             timeout: 60_000,
             stdio: ['ignore', 'pipe', 'ignore'],
             encoding: 'utf-8',
+            windowsHide: true,
         });
         return typeof out === 'string' && out.trim().length > 0;
     }
@@ -77,7 +78,7 @@ export function ensureClaudeInstalled(opts = {}) {
         return { installed: true, alreadyPresent: true };
     const { installArgv } = claudeInstallPlan();
     try {
-        execSync(installArgv.join(' '), { stdio: opts.quiet ? 'ignore' : 'inherit' });
+        execSync(installArgv.join(' '), { stdio: opts.quiet ? 'ignore' : 'inherit', windowsHide: true });
     }
     catch {
         // Fall through to a definitive PATH re-check rather than trusting the throw.

package/dist/commands/add.js

@@ -5,7 +5,7 @@ import { Command } from 'commander';
 import { post } from '../api.js';
 import { requireConfig } from '../config.js';
 import { sync } from '../sync.js';
-import { success, muted, bold } from '../colors.js';
+import { success, muted, bold, warning } from '../colors.js';
 import { run } from '../helpers/index.js';
 import { createProgressReporter, withSpinner } from '../progress.js';
 const STARTERS = [
@@ -225,6 +225,15 @@ export const addCommand = new Command('add')
         for (const n of data.notes)
             console.log(n);
     }
+    // Partial install (server HTTP 207): some files were dropped. Surface them so
+    // the user knows the install is incomplete rather than reading a clean success.
+    if (data.failed?.length) {
+        console.log('');
+        console.warn(warning(`${data.failed.length} file(s) failed to install:`));
+        for (const f of data.failed)
+            console.warn(warning(`  ! ${f.path}: ${f.error}`));
+        console.warn(warning(`Re-run \`gipity add ${data.kit ?? name}${opts.force ? ' --force' : ''}\` to retry the dropped files.`));
+    }
     // After scaffolding an app, point at kits as the next step - they add
     // features (multiplayer, etc.) into the app you just created.
     if (data.kind !== 'kit' && KITS.length > 0) {

package/dist/commands/bug.js

@@ -0,0 +1,69 @@
+import { Command } from 'commander';
+import { get, post } from '../api.js';
+import { resolveProjectContext } from '../config.js';
+import { bold, muted, success, warning } from '../colors.js';
+import { run } from '../helpers/index.js';
+// Kept in sync with @easyclaw/shared BUG_REPORT_CATEGORIES / _SEVERITIES (the CLI
+// package can't import the server's shared package). The server validates
+// authoritatively; these are for --help and a friendly client-side check.
+const CATEGORIES = ['cli', 'deploy', 'template', 'kit', 'db', 'docs', 'skill', 'service', 'sandbox', 'other'];
+const SEVERITIES = ['S1', 'S2', 'S3', 'S4'];
+const SEVERITY_HINT = 'S1=blocker, S2=major, S3=minor, S4=friction';
+export const bugCommand = new Command('bug')
+    .description('Report Gipity platform bugs / friction in real time')
+    .addHelpText('after', `\nCapture platform friction the moment you hit it — even one you worked around —` +
+    `\nso the team can triage it into a fix.\n` +
+    `\nCategories: ${CATEGORIES.join(', ')}` +
+    `\nSeverity:   ${SEVERITY_HINT}` +
+    `\nNever include PII or user data — describe the platform problem in the abstract.`);
+bugCommand
+    .command('report')
+    .description('File a bug / friction report about the Gipity platform')
+    .requiredOption('--category <cat>', `One of: ${CATEGORIES.join(', ')}`)
+    .requiredOption('--severity <sev>', SEVERITY_HINT)
+    .requiredOption('--summary <text>', 'One line, 7 words max. No PII/user data.')
+    .option('--detail <text>', 'Succinct: what you did, what failed, the workaround. No PII/user data.')
+    .option('--project <guid-or-slug>', 'Attribute to a specific project instead of cwd / Home')
+    .option('--json', 'Output raw JSON')
+    .action((opts) => run('Bug report', async () => {
+    const category = String(opts.category).toLowerCase();
+    const severity = /^[1-4]$/.test(opts.severity) ? `S${opts.severity}` : String(opts.severity).toUpperCase();
+    if (!CATEGORIES.includes(category))
+        throw new Error(`--category must be one of: ${CATEGORIES.join(', ')}`);
+    if (!SEVERITIES.includes(severity))
+        throw new Error(`--severity must be one of: ${SEVERITY_HINT}`);
+    if (String(opts.summary).trim().split(/\s+/).filter(Boolean).length > 7) {
+        throw new Error('--summary must be 7 words or fewer');
+    }
+    const { config } = await resolveProjectContext({ projectOverride: opts.project });
+    const res = await post(`/api/${config.projectGuid}/services/bug-report/submit`, { category, severity, summary: opts.summary, detail: opts.detail });
+    if (opts.json) {
+        console.log(JSON.stringify(res.data));
+        return;
+    }
+    console.log(success(`✓ Bug report filed (${res.data.report_guid}) — queued for triage.`));
+}));
+bugCommand
+    .command('list')
+    .description('List the bug / friction reports you have filed')
+    .option('--project <guid-or-slug>', 'Resolve auth against a specific project instead of cwd / Home')
+    .option('--json', 'Output raw JSON')
+    .action((opts) => run('Bug report', async () => {
+    const { config } = await resolveProjectContext({ projectOverride: opts.project });
+    const res = await get(`/api/${config.projectGuid}/services/bug-report/list`);
+    if (opts.json) {
+        console.log(JSON.stringify(res.data));
+        return;
+    }
+    const rows = res.data;
+    if (!rows.length) {
+        console.log(warning('No bug reports filed yet.'));
+        return;
+    }
+    console.log(bold(`${rows.length} report${rows.length === 1 ? '' : 's'}`));
+    for (const r of rows) {
+        console.log(`  ${r.severity}  ${muted(r.category.padEnd(8))} ${r.summary}  ${muted(`[${r.status}]`)}`);
+        console.log(muted(`      ${r.report_guid}  ${r.created_at}`));
+    }
+}));
+//# sourceMappingURL=bug.js.map

package/dist/commands/credits.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
-import { spawn } from 'node:child_process';
-import { get } from '../api.js';
-import { brand, muted } from '../colors.js';
+import { spawnCommand } from '../platform.js';
+import { get, post, ApiError } from '../api.js';
+import { brand, dim, bold, muted, success } from '../colors.js';
 import { run, printList } from '../helpers/index.js';
 const PRICING_URL = 'https://prompt.gipity.ai/pricing';
 function openInBrowser(url) {
@@ -12,7 +12,7 @@ function openInBrowser(url) {
         process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]] :
             ['xdg-open', [url]];
     try {
-        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        const child = spawnCommand(cmd, args, { stdio: 'ignore', detached: true });
         // A missing/non-executable launcher (ENOENT, or EACCES on WSL/minimal Linux
         // where xdg-open isn't runnable) is reported ASYNCHRONOUSLY via an 'error'
         // event - not a throw - so the try/catch alone can't stop it. With no
@@ -25,18 +25,92 @@ function openInBrowser(url) {
         // Synchronous spawn failure - caller prints the URL.
     }
 }
+// ---- Plan limits formatting (folded in from the old `plan` command) ----
+// Every key the plan definition enforces is rendered, so `credits` /
+// `credits list` are a full-transparency view of what your plan actually caps.
+const LIMIT_LABELS = {
+    maxProjects: 'Projects',
+    maxDatabases: 'Databases',
+    storageQuotaBytes: 'Storage',
+    maxWorkflows: 'Workflows',
+    minCronIntervalHours: 'Cron frequency',
+    maxConcurrentChats: 'Concurrent chats',
+    deployRatePerMinute: 'Deploys/min',
+    testFileConcurrency: 'Parallel tests',
+};
+// Nested serviceLimits (media generation entitlements). Convention:
+// -1 = unlimited, 0 = Pro-only (blocked on free), N = N free uses/month.
+const SERVICE_LABELS = {
+    video: 'Video generation',
+    music: 'Music generation',
+    image: 'Image generation',
+    audio: 'Speech & sound FX',
+};
+function formatLimit(key, value) {
+    if (typeof value !== 'number')
+        return String(value);
+    if (key === 'storageQuotaBytes') {
+        const gb = value / (1024 ** 3);
+        return `${gb.toFixed(gb >= 1 ? 1 : 2)} GB`;
+    }
+    if (key === 'minCronIntervalHours') {
+        return value === 0 ? 'no minimum' : `${value}h minimum`;
+    }
+    return value.toLocaleString();
+}
+function formatServiceLimit(value) {
+    if (value === -1)
+        return 'unlimited';
+    if (value === 0)
+        return 'Pro only';
+    if (typeof value === 'number')
+        return `${value.toLocaleString()}/mo free`;
+    return String(value);
+}
+function renderLimits(limits, indent = '') {
+    for (const key of Object.keys(LIMIT_LABELS)) {
+        const value = limits[key];
+        if (value !== undefined) {
+            console.log(`${indent}${LIMIT_LABELS[key].padEnd(18)} ${formatLimit(key, value)}`);
+        }
+    }
+    const services = limits.serviceLimits;
+    if (services && typeof services === 'object') {
+        console.log(`${indent}Media generation`);
+        for (const key of Object.keys(SERVICE_LABELS)) {
+            const value = services[key];
+            if (value !== undefined) {
+                console.log(`${indent}  ${SERVICE_LABELS[key].padEnd(16)} ${formatServiceLimit(value)}`);
+            }
+        }
+    }
+}
+// `credits` is the single account/billing hub: tier, live balance, the full set
+// of plan limits, and an upgrade nudge. `plan` aliases to it (so old muscle
+// memory resolves to one implementation); compare plans with `plan list`.
 export const creditsCommand = new Command('credits')
-    .description('View credits')
+    .alias('plan')
+    .description('Show your plan, credit balance, and limits')
     .option('--json', 'Output as JSON')
     .action((opts) => run('Credits', async () => {
+    // Version retention rides alongside the Storage limit; a failure fetching it
+    // must not sink the whole view, so degrade to null and omit the line.
+    const fetchRetention = () => get('/users/me/retention').then(r => r.data).catch(() => null);
     if (opts.json) {
-        const res = await get('/credits/balance');
-        console.log(JSON.stringify(res.data));
+        const [balRes, limitsRes, subRes, retention] = await Promise.all([
+            get('/credits/balance'),
+            get('/users/me/limits'),
+            get('/credits/subscription'),
+            fetchRetention(),
+        ]);
+        console.log(JSON.stringify({ subscription: subRes.data, balance: balRes.data, limits: limitsRes.data, retention }));
         return;
     }
-    const [balRes, subRes] = await Promise.all([
+    const [balRes, subRes, limitsRes, retention] = await Promise.all([
         get('/credits/balance'),
         get('/credits/subscription'),
+        get('/users/me/limits'),
+        fetchRetention(),
     ]);
     const sub = subRes.data;
     const tierLabel = sub.tier === 'pro' ? 'Gipity Pro' : 'Free';
@@ -45,17 +119,170 @@ export const creditsCommand = new Command('credits')
     if (balRes.data.balances.length > 0) {
         for (const b of balRes.data.balances) {
             const exp = new Date(b.expiresAt).toLocaleDateString();
-            console.log(`${b.source}: ${b.creditsRemaining.toLocaleString()}  ${muted(`expires ${exp}`)}`);
+            console.log(`  ${b.source}: ${b.creditsRemaining.toLocaleString()}  ${muted(`expires ${exp}`)}`);
         }
     }
+    console.log('\nLimits:');
+    renderLimits(limitsRes.data.limits, '  ');
+    if (retention) {
+        console.log(`  ${'Version retention'.padEnd(18)} ${retention.days} days / ${retention.count} copies`);
+    }
+    console.log('');
+    if (sub.tier !== 'pro') {
+        console.log(dim('Upgrade to Gipity Pro for higher limits and 20,000 credits/mo — run `gipity credits buy`.'));
+    }
+    else {
+        console.log(dim('Need more credits? Run `gipity credits list` to see credit packs, then `gipity credits buy <pack>`.'));
+    }
 }));
+// `credits list` compares every plan (with full limits) and the available
+// credit packs — the "what can I upgrade to" view.
 creditsCommand
-    .command('buy')
-    .description('Open the credits purchase page in your browser')
-    .action(() => run('Buy credits', async () => {
-    console.log(`Opening ${brand(PRICING_URL)} in your browser...`);
-    openInBrowser(PRICING_URL);
-    console.log(muted("If your browser didn't open automatically, copy the URL above."));
+    .command('list')
+    .description('Compare all plans and credit packs')
+    .option('--json', 'Output as JSON')
+    // optsWithGlobals(): the parent `credits` command also declares --json, which
+    // commander binds to the parent - read merged opts so --json is seen here.
+    .action((_opts, cmd) => run('Plans', async () => {
+    const opts = cmd.optsWithGlobals();
+    const [plansRes, productsRes, subRes] = await Promise.all([
+        get('/plans'),
+        get('/credits/products'),
+        get('/credits/subscription'),
+    ]);
+    if (opts.json) {
+        console.log(JSON.stringify({ currentTier: subRes.data.tier, plans: plansRes.data, products: productsRes.data }));
+        return;
+    }
+    const currentTier = subRes.data.tier;
+    const plans = plansRes.data;
+    if (plans.length === 0) {
+        console.log('No active plans.');
+        return;
+    }
+    console.log(bold('Plans'));
+    for (const plan of plans) {
+        const marker = plan.tier === currentTier ? brand('* ') : '  ';
+        const price = plan.monthlyPriceUsd > 0 ? ` - $${plan.monthlyPriceUsd}/mo` : ' - Free';
+        const credits = plan.monthlyCredits > 0
+            ? ` - ${plan.monthlyCredits.toLocaleString()} credits/mo (${plan.creditExpiryDays}-day expiry)`
+            : '';
+        console.log(`${marker}${plan.displayName} (${plan.tier})${price}${credits}`);
+        renderLimits(plan.limits, '      ');
+        console.log('');
+    }
+    const packs = productsRes.data.filter(p => p.type === 'one_time');
+    if (packs.length > 0) {
+        console.log(bold('Credit packs') + muted('  (require an active Pro subscription)'));
+        for (const pack of packs) {
+            const lock = pack.available ? '' : muted('  [Pro only]');
+            console.log(`  ${pack.name} - $${pack.amountUsd} - ${pack.credits.toLocaleString()} credits${lock}`);
+        }
+        console.log('');
+    }
+    console.log(dim('* = your current plan.  Upgrade or top up with `gipity credits buy [pro|<pack-credits>]`.'));
+}));
+// `credits buy` is the ONE purchase command. It resolves the target to a
+// Stripe price and prints a checkout link (agent-friendly: the link is always
+// printed so it can be relayed to the user; --open also launches a browser).
+creditsCommand
+    .command('buy [target]')
+    .alias('upgrade')
+    .description('Upgrade your plan or buy a credit pack (target: a tier like "pro", or a pack credit amount)')
+    .option('--open', 'Open the checkout page in your browser')
+    .option('--json', 'Output the checkout URL as JSON')
+    // optsWithGlobals(): the parent `credits` command also declares --json, which
+    // commander binds to the parent - read merged opts so --json/--open are seen here.
+    .action((target, _opts, cmd) => run('Buy', async () => {
+    const opts = cmd.optsWithGlobals();
+    const [productsRes, subRes] = await Promise.all([
+        get('/credits/products'),
+        get('/credits/subscription'),
+    ]);
+    const products = productsRes.data;
+    const currentTier = subRes.data.tier;
+    // Resolve the target product. With no arg, default to the first available
+    // paid subscription (the upgrade path). With an arg, match a plan/pack by
+    // name or credit amount, mirroring the cloud agent's product keys.
+    // Non-happy exits must stay parseable under --json (agents rely on it), so
+    // emit a JSON { error } instead of prose when the flag is set.
+    const bail = (message, humanLines) => {
+        if (opts.json)
+            console.log(JSON.stringify({ error: message }));
+        else
+            for (const line of humanLines)
+                console.log(line);
+    };
+    let product;
+    if (!target) {
+        product = products.find(p => p.type === 'subscription' && p.available);
+        if (!product) {
+            bail(currentTier === 'pro'
+                ? "You're already on Gipity Pro. To top up credits, run `gipity credits list` and buy a pack, e.g. `gipity credits buy 20000`."
+                : 'No upgrade plan is available right now.', [
+                currentTier === 'pro'
+                    ? `You're already on ${brand('Gipity Pro')}. To top up credits, run \`gipity credits list\` and buy a pack, e.g. \`gipity credits buy 20000\`.`
+                    : 'No upgrade plan is available right now.',
+                dim(`Browse everything at ${PRICING_URL}`),
+            ]);
+            return;
+        }
+    }
+    else {
+        const key = target.toLowerCase();
+        product = products.find(p => p.type === 'subscription' && p.name.toLowerCase() === key)
+            // pack keyed by credit amount, e.g. "20000" - MUST be a pack, not a
+            // subscription (Pro's monthly_credits can equal a pack's credit count).
+            ?? products.find(p => p.type === 'one_time' && String(p.credits) === key)
+            // accept "pro" against the single paid plan when only one exists
+            ?? (key === 'pro' ? products.find(p => p.type === 'subscription') : undefined);
+        if (!product) {
+            bail(`Unknown option "${target}". Run \`gipity credits list\` to see plans and packs.`, [`Unknown option "${target}". Run \`gipity credits list\` to see plans and packs.`]);
+            return;
+        }
+        if (!product.available) {
+            bail(product.type === 'subscription'
+                ? `You're already on ${product.name}.`
+                : 'Credit packs require an active Pro subscription. Run `gipity credits buy pro` first.', [product.type === 'subscription'
+                    ? `You're already on ${brand(product.name)}.`
+                    : 'Credit packs require an active Pro subscription. Run `gipity credits buy pro` first.']);
+            return;
+        }
+    }
+    try {
+        const res = await post('/credits/purchase', { priceId: product.priceId });
+        const url = res.data.checkoutUrl;
+        if (opts.json) {
+            console.log(JSON.stringify({ product: product.name, amountUsd: product.amountUsd, checkoutUrl: url }));
+            return;
+        }
+        const verb = product.type === 'subscription' ? 'Upgrading to' : 'Buying';
+        const per = product.type === 'subscription' ? '/mo' : '';
+        console.log(`${verb} ${brand(product.name)} ${muted(`($${product.amountUsd}${per}, ${product.credits.toLocaleString()} credits)`)}`);
+        console.log('');
+        console.log(`  ${bold('Checkout:')} ${success(url)}`);
+        console.log('');
+        console.log(dim('Open the link to complete your purchase — 2 minutes, cancel anytime. Your plan unlocks the moment payment clears.'));
+        if (opts.open)
+            openInBrowser(url);
+    }
+    catch (err) {
+        // Payments not configured / Stripe hiccup: fall back to the pricing page
+        // so the user is never dead-ended.
+        if (err instanceof ApiError) {
+            if (opts.json) {
+                console.log(JSON.stringify({ error: err.message, checkoutUrl: null, fallbackUrl: PRICING_URL }));
+            }
+            else {
+                console.log(muted(`Couldn't create a direct checkout link (${err.message}).`));
+                console.log(`Complete your purchase at ${brand(PRICING_URL)}`);
+            }
+            if (opts.open)
+                openInBrowser(PRICING_URL);
+            return;
+        }
+        throw err;
+    }
 }));
 creditsCommand
     .command('usage')

package/dist/commands/job.js

@@ -193,7 +193,7 @@ jobCommand
     .action(async (name, opts) => {
     const { existsSync, statSync } = await import('node:fs');
     const { resolve, join } = await import('node:path');
-    const { spawn, spawnSync } = await import('node:child_process');
+    const { spawnCommand, spawnSyncCommand } = await import('../platform.js');
     const jobDir = resolve(process.cwd(), 'jobs', name);
     if (!existsSync(jobDir) || !statSync(jobDir).isDirectory()) {
         console.error(clrError(`jobs/${name}/ not found in current directory`));
@@ -213,7 +213,7 @@ jobCommand
         process.exit(1);
     }
     // Confirm docker is reachable before bothering to build args.
-    const probe = spawnSync('docker', ['info'], { stdio: 'ignore' });
+    const probe = spawnSyncCommand('docker', ['info'], { stdio: 'ignore' });
     if (probe.status !== 0) {
         console.error(clrError('docker daemon not reachable. Start Docker Desktop / dockerd and retry.'));
         process.exit(1);
@@ -240,7 +240,7 @@ jobCommand
         shellCmd = `echo '[run-local] running ${handlerCmd} (${picked.runtime})' >&2 && exec ${handlerCmd}`;
     }
     const runArgs = ['run', ...sharedArgs, '--entrypoint', 'sh', opts.image, '-c', shellCmd];
-    const child = spawn('docker', runArgs, { stdio: 'inherit' });
+    const child = spawnCommand('docker', runArgs, { stdio: 'inherit' });
     // A missing `docker` binary is reported asynchronously via 'error' (not a
     // throw), so a try/catch can't stop it - without this handler Node crashes
     // with a raw stack trace instead of a clear message.

package/dist/commands/push.js

@@ -11,9 +11,13 @@ export const pushCommand = new Command('push')
     try {
         const fullPath = resolve(file);
         if (opts.background) {
-            // Fork to background - import child_process dynamically
-            const { fork } = await import('child_process');
-            const child = fork(process.argv[1], ['push', fullPath, '--quiet'], {
+            // Detach a background `gipity push` and exit immediately. Goes through
+            // spawnCommand (Node binary running our own entry script - no IPC
+            // channel is needed, so spawn beats fork), which defaults
+            // `windowsHide: true` so the detached child never flashes a console
+            // window on Windows.
+            const { spawnCommand } = await import('../platform.js');
+            const child = spawnCommand(process.execPath, [process.argv[1], 'push', fullPath, '--quiet'], {
                 detached: true,
                 stdio: 'ignore',
             });

package/dist/commands/relay.js

@@ -14,7 +14,7 @@ import { bold, brand, dim, success, error as clrError, muted, } from '../colors.
 import * as state from '../relay/state.js';
 import * as daemon from '../relay/daemon.js';
 import { UnsupportedPlatformError } from '../relay/installers.js';
-import { pairDevice, startDaemon, installAutostart } from '../relay/setup.js';
+import { pairDevice, startDaemon, installAutostart, removeAutostart } from '../relay/setup.js';
 import { registerInstallCommands } from './relay-install.js';
 export const relayCommand = new Command('relay')
     .description('Pair with the web CLI');
@@ -269,8 +269,32 @@ relayCommand
         console.error(muted('Local token cleared anyway. Visit the web CLI to confirm the server-side revoke.'));
     }
     state.clearDevice();
+    // Remove the OS autostart unit too. Otherwise the login service relaunches
+    // `relay run`, which - finding no device but a valid login - silently
+    // re-registers a NEW device, undoing this revoke (on macOS the old
+    // KeepAlive=true even relaunched on the clean exit). Best-effort: an
+    // unsupported OS or a missing unit is fine.
+    let autostartRemoved = false;
+    try {
+        autostartRemoved = removeAutostart().ok;
+    }
+    catch { /* unsupported platform / no unit - ignore */ }
+    // Stop the currently-running daemon now rather than waiting for it to
+    // notice via a 401 on its next poll (~up to a hold cycle).
+    const pidPath = state.getDaemonPidPath();
+    if (existsSync(pidPath)) {
+        const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+        if (pid && !isNaN(pid)) {
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch { /* already gone */ }
+        }
+    }
     console.log(success('Device revoked + local state cleared.'));
-    console.log(muted('Any running background service will notice and exit within ~30s.'));
+    console.log(muted(autostartRemoved
+        ? 'Auto-start removed and the background service was signalled to stop.'
+        : 'The background service was signalled to stop.'));
 });
 // ─── gipity relay log ──────────────────────────────────────────────────
 relayCommand

package/dist/commands/remove.js

@@ -23,10 +23,16 @@ export const removeCommand = new Command('remove')
     const res = opts.json
         ? await doRemove()
         : await withSpinner('Removing…', doRemove, { done: null });
-    // Force the pull so the kit's deletions land locally without tripping the
-    // bulk-deletion guard - the removal is an explicit, user-invoked action.
-    const syncResult = await sync({ interactive: false, force: true, progress: opts.json ? undefined : createProgressReporter() });
     const data = res.data;
+    // Pull the kit's deletions locally. Whitelist ONLY the kit's own removed files
+    // so they bypass the bulk-delete guard (the removal is explicit), while any
+    // unrelated mass deletion pending on either side is still guarded - a blanket
+    // `force` here would let that ride in silently.
+    const syncResult = await sync({
+        interactive: false,
+        deleteWhitelist: data.removed ?? [],
+        progress: opts.json ? undefined : createProgressReporter(),
+    });
     if (opts.json) {
         console.log(JSON.stringify({ ...data, synced: syncResult.applied }));
         return;

package/dist/commands/storage.js

@@ -0,0 +1,64 @@
+import { Command } from 'commander';
+import { get, patch } from '../api.js';
+import { brand, muted } from '../colors.js';
+import { run } from '../helpers/index.js';
+/** Parse a CLI flag value as a positive whole number, or throw a friendly error.
+ *  The server is the source of truth for the plan-cap bound; this just rejects
+ *  the obviously-invalid input locally before spending a round trip. */
+function parsePositiveInt(raw, flag) {
+    if (!/^\d+$/.test(raw.trim())) {
+        throw new Error(`${flag} must be a positive whole number.`);
+    }
+    const n = parseInt(raw, 10);
+    if (n < 1)
+        throw new Error(`${flag} must be a positive whole number.`);
+    return n;
+}
+function printRetention(d, updated) {
+    console.log(updated ? 'Version retention updated:' : 'Version retention:');
+    console.log(`  ${brand(`${d.days} days`)} / ${brand(`${d.count} copies`)}  ${muted('(whichever prunes first)')}`);
+    const daysNote = d.customDays ? 'custom' : 'plan default';
+    const countNote = d.customCount ? 'custom' : 'plan default';
+    console.log(`  ${muted(`days: ${daysNote}, copies: ${countNote}`)}`);
+    console.log(muted(`Plan allows up to ${d.maxDays} days / ${d.maxCount} copies.`));
+}
+export const storageCommand = new Command('storage')
+    .description('Manage file storage settings');
+storageCommand
+    .command('retention')
+    .description('View or adjust your file version-retention policy')
+    .option('--days <n>', 'Keep versions for at most N days (1..plan cap)')
+    .option('--count <n>', 'Keep at most N copies per file (1..plan cap)')
+    .option('--reset', 'Reset both days and copies to the plan default')
+    .option('--json', 'Output as JSON')
+    .action((opts) => run('Retention', async () => {
+    const hasSet = opts.days !== undefined || opts.count !== undefined;
+    if (opts.reset && hasSet) {
+        throw new Error('Use either --reset or --days/--count, not both.');
+    }
+    let data;
+    if (opts.reset) {
+        // null resets a field to the plan default; send both.
+        const res = await patch('/users/me/retention', { days: null, count: null });
+        data = res.data;
+    }
+    else if (hasSet) {
+        const body = {};
+        if (opts.days !== undefined)
+            body.days = parsePositiveInt(opts.days, '--days');
+        if (opts.count !== undefined)
+            body.count = parsePositiveInt(opts.count, '--count');
+        const res = await patch('/users/me/retention', body);
+        data = res.data;
+    }
+    else {
+        const res = await get('/users/me/retention');
+        data = res.data;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(data));
+        return;
+    }
+    printRetention(data, opts.reset === true || hasSet);
+}));
+//# sourceMappingURL=storage.js.map

package/dist/commands/uninstall.js

@@ -12,7 +12,7 @@ import { Command } from 'commander';
 import { existsSync, rmSync, unlinkSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join, resolve } from 'path';
-import { spawnSync } from 'child_process';
+import { spawnSyncCommand } from '../platform.js';
 import { post } from '../api.js';
 import { getAuth } from '../auth.js';
 import { confirm, getAutoConfirm } from '../utils.js';
@@ -92,7 +92,7 @@ function removeServiceUnit() {
         // is fine if the service was never installed.
         let allOk = true;
         for (const argv of plan.disableCmds) {
-            const r = spawnSync(argv[0], argv.slice(1), { stdio: 'ignore' });
+            const r = spawnSyncCommand(argv[0], argv.slice(1), { stdio: 'ignore' });
             if (r.status !== 0)
                 allOk = false;
         }

package/dist/commands/upload.js

@@ -32,7 +32,6 @@ export const uploadCommand = new Command('upload')
     .argument('<src>', 'Local source file or directory')
     .argument('[dest]', 'Destination path in the project (defaults to /)')
     .option('-r, --recursive', 'Upload a directory recursively')
-    .option('--overwrite', 'Force a new version even if the file is byte-identical to the current version')
     .option('--mime <type>', 'Override the content-type (default: detect from extension)')
     .option('--concurrency <n>', `Parallel files (default ${UPLOAD_CONCURRENCY})`)
     .option('--dry-run', 'Print what would be uploaded; do not call the network')
@@ -85,7 +84,7 @@ export const uploadCommand = new Command('upload')
             return;
         }
         const concurrency = Math.max(1, parseInt(opts.concurrency ?? String(UPLOAD_CONCURRENCY), 10));
-        const uploadOpts = { mime: opts.mime, overwrite: opts.overwrite };
+        const uploadOpts = { mime: opts.mime };
         let cursor = 0;
         let uploaded = 0, skipped = 0, resumed = 0, failed = 0;
         const workers = [];