gipity 1.0.413 → 1.0.416

package/dist/commands/status.js

@@ -5,7 +5,7 @@ import { homedir } from 'os';
 import { getAuth, sessionExpired } from '../auth.js';
 import { getConfig, liveUrl } from '../config.js';
 import { brand, success, warning, muted, error as clrError } from '../colors.js';
-import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, setupClaudeHooks, ensureGipityPlugin, ensureGipityPluginInstalled, userScopePluginCurrent } from '../setup.js';
+import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, setupClaudeHooks, ensureGipityPlugin, ensureGipityPluginInstalled, userScopeInstallState } from '../setup.js';
 /** Hooks ship in the Gipity Claude Code plugin now. "Installed" means three
  *  things must all hold: the user-scope settings register the marketplace and
  *  enable the plugin (declarative), AND Claude Code actually has a user-scope
@@ -27,9 +27,15 @@ function checkGipityPlugin() {
         missing.push('marketplace');
     if (settings?.enabledPlugins?.[GIPITY_PLUGIN_ID] !== true)
         missing.push('plugin');
-    if (!userScopePluginCurrent())
+    const install = userScopeInstallState();
+    if (!install.current)
         missing.push('install');
-    return { missing, ok: missing.length === 0 };
+    // "stale" = declaratively enabled AND a user-scope install exists; it's just
+    // behind the version this CLI needs. The hooks still LOAD (at the old
+    // version), so this is a version-lag update, not a dead plugin - don't warn
+    // as if files aren't syncing at all. Only true when `install` is the sole gap.
+    const stale = missing.length === 1 && missing[0] === 'install' && install.exists;
+    return { missing, ok: missing.length === 0, stale };
 }
 export const statusCommand = new Command('status')
     .description('Show project and login status')
@@ -89,13 +95,28 @@ export const statusCommand = new Command('status')
             ensureGipityPlugin(true);
             setupClaudeHooks();
             // Re-enabling the declarative keys isn't enough on CC >=2.1.x - also
-            // materialize the user-scope install so the hooks actually load.
+            // materialize (or update) the user-scope install so the hooks load.
             ensureGipityPluginInstalled();
-            console.log(`${muted('Hooks:')}   ${success('repaired - Gipity plugin re-enabled')}`);
+            // Re-check rather than claim success blindly: a stale user-scope
+            // install only advances via `plugin update`, and if `claude` is off
+            // PATH nothing changed at all - reporting "repaired" then would be a
+            // lie the next `gipity status` immediately contradicts.
+            const after = checkGipityPlugin();
+            if (after.ok) {
+                console.log(`${muted('Hooks:')}   ${success('repaired - Gipity plugin enabled')}`);
+            }
+            else {
+                console.log(`${muted('Hooks:')}   ${warning(`repair incomplete (still missing: ${after.missing.join(', ')})`)}`);
+                console.log(muted('Ensure `claude` is on PATH, then re-run. Restart Claude Code to load the update.'));
+            }
+        }
+        else if (hookCheck.stale) {
+            console.log(`${muted('Hooks:')}   ${warning('Gipity plugin out of date (an update is available)')}`);
+            console.log(muted('Hooks still load, but run `gipity status --repair-hooks` to update to the latest.'));
         }
         else {
             console.log(`${muted('Hooks:')}   ${warning(`Gipity plugin not enabled (missing: ${hookCheck.missing.join(', ')})`)}`);
-            console.log(muted('Run `gipity status --repair-hooks` to re-enable.'));
+            console.log(muted('Run `gipity status --repair-hooks` to enable.'));
             console.log(muted('Without it, files don\'t auto-sync and web CLI dispatches can\'t show Claude Code output.'));
         }
     }

package/dist/commands/text.js

@@ -140,7 +140,7 @@ const analyzeCommand = new Command('analyze')
 // Parent namespace. One capability today (analyze); namespaced for a lean
 // top-level surface and room for future text operations.
 export const textCommand = new Command('text')
-    .description('Analyze text')
+    .description('Deterministic text analysis (counts, substrings) - no LLM needed')
     .addHelpText('after', `\nDeterministic char/word counts, frequency, and occurrences (${brand('text analyze')}). Local, no network.`)
     .addCommand(analyzeCommand);
 textCommand.action(() => {

package/dist/index.js

@@ -30,6 +30,8 @@ import { storageCommand } from './commands/storage.js';
 import { claudeCommand } from './commands/claude.js';
 import { addCommand } from './commands/add.js';
 import { removeCommand } from './commands/remove.js';
+import { saveCommand } from './commands/save.js';
+import { loadCommand } from './commands/load.js';
 import { logsCommand } from './commands/logs.js';
 import { pageCommand } from './commands/page.js';
 import { recordsCommand } from './commands/records.js';
@@ -39,6 +41,7 @@ import { secretsCommand } from './commands/secrets.js';
 import { notifyCommand } from './commands/notify.js';
 import { bugCommand } from './commands/bug.js';
 import { paymentsCommand } from './commands/payments.js';
+import { githubCommand } from './commands/github.js';
 import { jobCommand } from './commands/job.js';
 import { rbacCommand } from './commands/rbac.js';
 import { auditCommand } from './commands/audit.js';
@@ -124,25 +127,55 @@ const program = new Command();
 // global value-option precedes it (e.g. `gipity --api-base X workflow create
 // --from Y`). enablePositionalOptions draws the boundary at the first command.
 program.enablePositionalOptions();
-// ── Command groups (logical ordering within each) ──────────────────────
-const commonGroup = [skillCommand, projectCommand, addCommand, removeCommand, deployCommand];
-const connectGroup = [claudeCommand, setupCommand, relayCommand];
-const projectGroup = [domainCommand, statusCommand, initCommand];
-const filesGroup = [fileCommand, storageCommand, syncCommand, pushCommand, uploadCommand];
-const appBuildingGroup = [testCommand, fnCommand, serviceCommand, secretsCommand, notifyCommand, paymentsCommand, jobCommand, dbCommand, logsCommand, workflowCommand, realtimeCommand, rbacCommand, auditCommand, recordsCommand];
-const utilitiesGroup = [pageCommand, sandboxCommand, generateCommand, emailCommand, gmailCommand, locationCommand, textCommand];
-const agentGroup = [chatCommand, memoryCommand, agentCommand, approvalCommand, bugCommand];
-const setupGroup = [loginCommand, logoutCommand, tokenCommand, creditsCommand, doctorCommand, updateCommand, uninstallCommand];
+// ── Command groups (lifecycle order; logical ordering within each) ─────
+// Section names deliberately match the vocabulary of the generated CLAUDE.md
+// primer and the skill docs ("build loop: add → edit → deploy → page
+// inspect"), so an agent's first `--help` reads in the same terms as the rest
+// of its context. Humans get the same win: sections follow the order you
+// actually use them - orient, build, wire the backend, then everything else.
+const startGroup = [statusCommand, initCommand, skillCommand, projectCommand];
+const buildGroup = [addCommand, removeCommand, saveCommand, loadCommand, deployCommand, pageCommand, testCommand];
+const backendGroup = [dbCommand, fnCommand, secretsCommand, logsCommand, jobCommand, workflowCommand];
+const servicesGroup = [serviceCommand, generateCommand, notifyCommand, paymentsCommand, realtimeCommand, recordsCommand, rbacCommand, auditCommand, domainCommand, tokenCommand];
+const filesGroup = [syncCommand, fileCommand, pushCommand, uploadCommand, storageCommand];
+const gipGroup = [chatCommand, memoryCommand, agentCommand, approvalCommand, gmailCommand];
+const utilitiesGroup = [sandboxCommand, emailCommand, locationCommand, textCommand, bugCommand];
+const connectGroup = [loginCommand, logoutCommand, claudeCommand, setupCommand, relayCommand, githubCommand, creditsCommand, doctorCommand, updateCommand, uninstallCommand];
 const HELP_SECTIONS = [
-    { title: 'Common', cmds: commonGroup },
-    { title: 'Connect', cmds: connectGroup },
-    { title: 'Project', cmds: projectGroup },
+    { title: 'Start here', cmds: startGroup },
+    { title: 'App build & ship', cmds: buildGroup },
+    { title: 'App backend', cmds: backendGroup },
+    { title: 'App services', cmds: servicesGroup },
     { title: 'Files', cmds: filesGroup },
-    { title: 'App building', cmds: appBuildingGroup },
+    { title: 'Gip (cloud agent)', cmds: gipGroup },
     { title: 'Utilities', cmds: utilitiesGroup },
-    { title: 'Agent', cmds: agentGroup },
-    { title: 'Setup', cmds: setupGroup },
+    { title: 'Connect & setup', cmds: connectGroup },
 ];
+// Per-command deep-docs cross-links, rendered as a "Docs:" epilog on each
+// command's --help AND carried in the `help --json` manifest. This is the
+// bridge agents actually need - from "found the command" to "know the API
+// pattern" - without duplicating skill content in help text (skills stay the
+// single source of truth; this maps names only). Keys must be real skill
+// names (`gipity skill list`).
+const SKILL_DOCS = {
+    save: 'app-import',
+    load: 'app-import',
+    github: 'app-import',
+    deploy: 'deploy',
+    page: 'app-debugging',
+    test: 'app-testing',
+    db: 'app-database',
+    fn: 'app-development',
+    service: 'service-call',
+    notify: 'app-notify',
+    payments: 'app-payments',
+    realtime: 'app-realtime',
+    job: 'jobs',
+    sandbox: 'sandbox-tools',
+    gmail: 'google-services',
+    email: 'email',
+    location: 'location',
+};
 program
     .name('gipity')
     .description(`${brand(bold('Gipity CLI'))} ${dim('-')} ${GIPITY_TAGLINE.replace(/\.$/, '')}\n\n  ${dim('Hosting, databases, deploys, workflows, code execution, and monitoring - one place, agent-tuned. Pair with Claude Code or use standalone.')}`)
@@ -204,14 +237,72 @@ program.configureHelp({
             lines.push('');
         }
         lines.push(dim(`Run "${cmd.name()} <command> --help" for details on a specific command.`));
+        lines.push(dim(`Deep docs: "${cmd.name()} skill list". Machine-readable manifest: "${cmd.name()} help --json".`));
         lines.push('');
         return lines.join('\n');
     },
 });
 for (const cmd of HELP_SECTIONS.flatMap(s => s.cmds)) {
     configureHelp(cmd);
+    // "Docs:" epilog bridging this command's --help to its skill doc.
+    const skill = SKILL_DOCS[cmd.name()];
+    if (skill)
+        cmd.addHelpText('after', `Docs: gipity skill read ${skill}\n`);
     program.addCommand(cmd);
 }
+// ── `gipity help [command]` + `help --json` machine-readable manifest ───
+// The JSON manifest is generated from the SAME commander registry that
+// renders human help, so it cannot drift: name, args, options, subcommands,
+// group, and the skill cross-link per command. Meant for agents and tooling
+// that want the full surface in one parseable shot instead of N --help calls.
+program.helpCommand(false); // replace the builtin so we can add --json
+function manifestCommand(c) {
+    return {
+        name: c.name(),
+        aliases: c.aliases().slice(),
+        description: c.description(),
+        usage: `gipity ${fullCommandPath(c)} ${c.usage()}`.trim(),
+        args: c.registeredArguments.map(a => ({
+            name: a.name(),
+            required: a.required,
+            description: a.description || '',
+        })),
+        options: c.options.filter(o => !o.hidden).map(o => ({ flags: o.flags, description: o.description })),
+        subcommands: c.commands.filter(sc => !sc._hidden).map(manifestCommand),
+        skill: SKILL_DOCS[c.name()] ?? null,
+    };
+}
+function fullCommandPath(c) {
+    const parts = [];
+    for (let cur = c; cur && cur.parent; cur = cur.parent)
+        parts.unshift(cur.name());
+    return parts.join(' ');
+}
+program.addCommand(new Command('help')
+    .description('Show help; --json emits the full command manifest for agents/tools')
+    .argument('[command]', 'Show help for this command')
+    .option('--json', 'Output every command (args, options, subcommands, docs links) as JSON')
+    .action((name, opts) => {
+    if (opts.json) {
+        const manifest = {
+            name: 'gipity',
+            version: pkg.version,
+            docs: 'Run `gipity skill list` for deep task docs; each command may carry a `skill` cross-link.',
+            sections: HELP_SECTIONS.map(s => ({
+                title: s.title,
+                commands: s.cmds.map(manifestCommand),
+            })),
+        };
+        console.log(JSON.stringify(manifest, null, 2));
+        return;
+    }
+    if (name) {
+        const target = program.commands.find(c => c.name() === name || c.aliases().includes(name));
+        if (target)
+            target.help();
+    }
+    program.help();
+}));
 // ── Malformed invocation → print the command's help inline, error LAST ──
 // When an agent guesses the wrong shape (excess args, unknown command/option,
 // missing arg), don't make it run `--help` as a second trip: render that exact

package/dist/knowledge.js

@@ -107,7 +107,9 @@ mkdir -p ~/GipityProjects/<slug> && cd ~/GipityProjects/<slug> && gipity init <s
 ## CLI quick reference
 
 Key commands: \`gipity add <template|kit>\`, \`gipity deploy dev\`, \`gipity sandbox run\`, \`gipity page inspect <url>\`, \`gipity page screenshot <url>\`, \`gipity db query "SQL"\`, \`gipity fn call <name>\`, \`gipity logs fn <name>\`, \`gipity secrets set <NAME> <value> [--account]\` (store an API key/token encrypted; read in functions via \`secrets.get('NAME')\` — never hardcode keys), \`gipity email send --to <addr> --subject <s> --body <b>\` (sends as \`gipity@gipity.ai\`; omit \`--to\` to self-send), \`gipity skill read <name>\`.
+Rename for findability: \`gipity project rename <name>\` renames the current project's display name (the slug and deployed URLs never change); \`gipity chat rename <title>\` renames the current chat's tab title. Both are the display label users scan to switch between tabs — retitle a chat when the conversation clearly shifts to a new topic (sparingly, not every turn), and keep every project/chat title SHORT: 2-4 words, ≤40 characters, no trailing punctuation (e.g. "Stripe checkout", "Tetris game").
 Pull an existing remote project local (given its URL/slug): \`mkdir -p ~/GipityProjects/<slug> && cd ~/GipityProjects/<slug> && gipity init <slug>\` (adopts the matching project and syncs files down - this is the "clone").
+Move whole apps in/out: \`gipity save\` (export this project as a portable \`.gip\` bundle), \`gipity load <file.gip | github:owner/repo>\` (import as a NEW project; \`--inspect\` to preview), \`gipity github connect\` (1-2 click GitHub access for imports). Porting a Vercel/Replit/Lovable app? Load the \`app-import\` skill first.
 For deterministic text questions (letter/word counts, substring occurrences, nth word/char, anagrams), use \`gipity text analyze "<text>"\` - local and instant, no sandbox or LLM needed.
 Hit a platform bug or friction? File it in real time: \`gipity bug report --category <cli|deploy|template|kit|db|docs|skill|service|sandbox|other> --severity <S1|S2|S3|S4> --summary "<7 words max>" [--detail "<what failed + workaround>"]\` (see below).
 Run \`gipity --help\` for the full list. Use \`--help\` on any command for details.
@@ -180,6 +182,7 @@ App development skills:
 - \`app-database\` - app Postgres database: migrations, the db helper, transactions, table permissions
 - \`app-debugging\` - debug a deployed app: page inspect/eval, screenshots, function logs
 - \`app-development\` - functions, database, and API
+- \`app-import\` - import apps from GitHub/.gip bundles (incl. Vercel/Replit/Lovable porting) and export any project as a portable .gip - app_import tool, gipity save/load
 - \`app-testing\` - testing deployed app functions (ctx.fn.call/callAs, the isolated test DB)
 - \`deploy\` - the deploy pipeline & gipity.yaml manifest
 - \`jobs\` - long-running CPU + GPU compute jobs (Python / Node / bash)

package/dist/relay/agent-token.js

@@ -19,6 +19,11 @@ import { hostname } from 'os';
 import { post, del } from '../api.js';
 import { resolveApiBase } from '../config.js';
 import * as state from './state.js';
+/** Relay agent tokens carry a finite expiry so an orphaned one - left behind
+ *  when a user deletes ~/.gipity by hand, losing the guid we'd revoke it with -
+ *  self-expires instead of living forever. A live relay is unaffected:
+ *  ensureRelayAgentToken() re-mints on the first 401 after expiry. */
+const RELAY_AGENT_TOKEN_EXPIRY_DAYS = 60;
 /** Validate a stored token against the API. Only a definitive 401 counts as
  *  invalid - transient failures (network, 5xx) must not discard a good token
  *  and trigger a re-mint storm. */
@@ -48,7 +53,7 @@ export async function ensureRelayAgentToken() {
     }
     try {
         const name = `Relay on ${state.getDevice()?.name ?? hostname()}`;
-        const res = await post('/auth/agent-tokens', { name });
+        const res = await post('/auth/agent-tokens', { name, expiresInDays: RELAY_AGENT_TOKEN_EXPIRY_DAYS });
         state.setAgentToken(res.data.token, res.data.shortGuid);
         return res.data.token;
     }

package/dist/relay/daemon.js

@@ -18,6 +18,7 @@ import { deviceFetch, bridgeAbort as bridgeAbortImpl } from './device-http.js';
 import { ensureRelayAgentToken } from './agent-token.js';
 import { redactEntries, redactString, normalizeSecrets } from './redact.js';
 import { getMachineId } from './machine-id.js';
+import { collectDiagnostics } from './diagnostics.js';
 // Re-exported so the existing `relay-bridge-abort.test.ts` keeps working.
 // New callers should import from device-http.js directly.
 export const bridgeAbort = bridgeAbortImpl;
@@ -28,6 +29,10 @@ export const RELAY_LOG_PATH = join(homedir(), '.gipity', 'relay.log');
 // slightly after its own deadline; we accept that. Values can be overridden
 // by env for tests.
 const HEARTBEAT_INTERVAL_MS = parseInt(process.env.GIPITY_RELAY_HEARTBEAT_MS || '60000', 10);
+// How often the heartbeat carries a fresh diagnostics snapshot (host specs +
+// versions). The 60s liveness ping stays bare; only this cadence runs the
+// costlier version/GPU probes. First tick fires immediately at daemon start.
+const DIAGNOSTICS_INTERVAL_MS = parseInt(process.env.GIPITY_RELAY_DIAGNOSTICS_MS || String(24 * 60 * 60 * 1000), 10);
 const LONG_POLL_TIMEOUT_MS = parseInt(process.env.GIPITY_RELAY_POLL_TIMEOUT_MS || '35000', 10);
 const BACKOFF_BASE_MS = parseInt(process.env.GIPITY_RELAY_BACKOFF_BASE_MS || '1000', 10);
 const BACKOFF_MAX_MS = parseInt(process.env.GIPITY_RELAY_BACKOFF_MAX_MS || '30000', 10);
@@ -284,9 +289,24 @@ async function heartbeatLoop(ctx) {
     // Log the "session expired" warning only on the transition into that state,
     // not every 60s, so a genuinely-lapsed session doesn't spam the relay log.
     let sessionWarnLogged = false;
+    // Diagnostics: attach a fresh snapshot on the first heartbeat and every
+    // DIAGNOSTICS_INTERVAL_MS after, but only if the user consented. Between
+    // refreshes the heartbeat is a bare liveness ping.
+    let lastDiagnosticsAt = 0;
     while (!ctx.abort.signal.aborted) {
         try {
-            const r = await deviceFetch('POST', '/remote-devices/heartbeat', {}, 10_000, ctx.abort.signal);
+            let body = {};
+            if (state.diagnosticsConsented() && Date.now() - lastDiagnosticsAt >= DIAGNOSTICS_INTERVAL_MS) {
+                try {
+                    body = { diagnostics: await collectDiagnostics() };
+                    lastDiagnosticsAt = Date.now();
+                }
+                catch (err) {
+                    // Never let a diagnostics probe failure block the liveness ping.
+                    log('debug', 'diagnostics collection failed', { err: err?.message });
+                }
+            }
+            const r = await deviceFetch('POST', '/remote-devices/heartbeat', body, 10_000, ctx.abort.signal);
             if (r.status === 401) {
                 log('warn', 'heartbeat 401 - device revoked, exiting clean');
                 ctx.abort.abort('revoked');

package/dist/relay/diagnostics.js

@@ -0,0 +1,173 @@
+/**
+ * Relay diagnostics snapshot: non-PII host + version telemetry the daemon
+ * reports on its heartbeat (once at startup, then ~daily). Sent as the
+ * heartbeat body `{ diagnostics }` and stored on the server as
+ * `remote_devices.diagnostics` (JSONB); the web client surfaces it in the
+ * Relays table (versions inline, host specs on hover).
+ *
+ * Design rules:
+ *   - EVERY probe is best-effort: a failure yields undefined/null for that
+ *     field, never a thrown error. `collectDiagnostics()` always resolves.
+ *   - NO personally-identifying data: no paths, no hostname, no username -
+ *     only counts and non-identifying machine specs.
+ *   - Cheap in-memory `os.*` reads are gathered inline; the costlier probes
+ *     (agent `--version` subprocesses, GPU detection) are bounded with a short
+ *     timeout and only run when the daemon refreshes the snapshot (startup +
+ *     ~daily), never on the plain 60s liveness ping.
+ *
+ * Wire shape mirrors packages/shared `RelayDiagnostics` on the platform side.
+ */
+import { cpus, freemem, totalmem, loadavg, release, uptime, homedir } from 'os';
+import { statfsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { resolveCommand, spawnCommand } from '../platform.js';
+import { cliVersion } from '../client-context.js';
+const PROBE_TIMEOUT_MS = 4000;
+/** Extract a semver-ish token from a `--version` line ("2.0.14 (Claude Code)"
+ *  → "2.0.14"). Returns undefined when nothing version-like is present.
+ *  Exported for unit tests. */
+export function parseVersion(out) {
+    const m = out.match(/\d+\.\d+(?:\.\d+)?(?:[-.\w]*)?/);
+    return m ? m[0] : undefined;
+}
+/**
+ * Run a command and capture stdout, ASYNC + non-blocking with a hard timeout.
+ * This must not be `spawnSync`: `collectDiagnostics()` runs inside the daemon's
+ * heartbeat loop, which shares one event loop with the dispatch + cancellation
+ * loops - a synchronous spawn would freeze all of them for the probe's
+ * duration. Resolves '' on spawn error, timeout (child SIGKILL'd), or non-zero
+ * exit with no output; never rejects.
+ */
+function runProbe(cmd, args) {
+    return new Promise((resolve) => {
+        let out = '';
+        let settled = false;
+        const done = (s) => { if (!settled) {
+            settled = true;
+            resolve(s);
+        } };
+        let child;
+        try {
+            child = spawnCommand(resolveCommand(cmd), args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        }
+        catch {
+            return done('');
+        }
+        const timer = setTimeout(() => { try {
+            child.kill('SIGKILL');
+        }
+        catch { /* gone */ } done(out); }, PROBE_TIMEOUT_MS);
+        child.stdout?.on('data', (d) => { out += d.toString(); });
+        child.on('error', () => { clearTimeout(timer); done(''); });
+        child.on('close', () => { clearTimeout(timer); done(out); });
+    });
+}
+/** Run `<cmd> --version` (bounded, best-effort). undefined if the command is
+ *  absent, errors, or prints nothing version-like. */
+async function probeVersion(cmd) {
+    return parseVersion(await runProbe(cmd, ['--version']));
+}
+/** Best-effort GPU description. Short-timeout, platform-specific, null on any
+ *  failure - never blocks the snapshot. */
+async function detectGpu() {
+    if (process.platform === 'darwin') {
+        const m = (await runProbe('system_profiler', ['SPDisplaysDataType'])).match(/Chipset Model:\s*(.+)/);
+        return m ? m[1].trim() : null;
+    }
+    if (process.platform === 'linux') {
+        // nvidia-smi is fast + precise when present; fall back to lspci.
+        const nvName = (await runProbe('nvidia-smi', ['--query-gpu=name', '--format=csv,noheader'])).split('\n')[0]?.trim();
+        if (nvName)
+            return nvName;
+        const line = (await runProbe('sh', ['-c', "lspci | grep -iE 'vga|3d|display'"])).split('\n')[0]?.trim();
+        if (!line)
+            return null;
+        // Strip the "00:02.0 VGA compatible controller: " prefix.
+        const after = line.split(/:\s/).slice(2).join(': ').trim();
+        return after || line;
+    }
+    if (process.platform === 'win32') {
+        const line = (await runProbe('wmic', ['path', 'win32_VideoController', 'get', 'name']))
+            .split('\n').map(l => l.trim()).filter(l => l && l !== 'Name')[0];
+        return line ?? null;
+    }
+    return null;
+}
+/** Free/total bytes on the projects volume (best-effort). */
+function diskUsage() {
+    try {
+        if (typeof statfsSync !== 'function')
+            return undefined;
+        const st = statfsSync(join(homedir(), 'GipityProjects'), { bigint: false });
+        if (!st || !st.bsize)
+            return undefined;
+        return { total: st.bsize * st.blocks, free: st.bsize * st.bavail };
+    }
+    catch {
+        // Projects dir may not exist yet - try the home volume instead.
+        try {
+            const st = statfsSync(homedir(), { bigint: false });
+            return { total: st.bsize * st.blocks, free: st.bsize * st.bavail };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+/** Count of directories under ~/GipityProjects (no names). */
+function localProjectCount() {
+    try {
+        return readdirSync(join(homedir(), 'GipityProjects'), { withFileTypes: true })
+            .filter(e => e.isDirectory() && !e.name.startsWith('.')).length;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Gather the full snapshot. Cheap `os.*` reads plus the bounded subprocess
+ * probes. Always resolves (best-effort per field).
+ */
+export async function collectDiagnostics() {
+    const cores = (() => { try {
+        return cpus();
+    }
+    catch {
+        return [];
+    } })();
+    // Run the subprocess probes concurrently (each already bounded + best-effort)
+    // so the whole snapshot costs one timeout, not the sum of four.
+    const [claude, codex, cursor, gpu] = await Promise.all([
+        probeVersion('claude'), probeVersion('codex'), probeVersion('cursor'), detectGpu(),
+    ]);
+    const agents = {};
+    if (claude)
+        agents.claude_code = claude;
+    if (codex)
+        agents.codex = codex;
+    if (cursor)
+        agents.cursor = cursor;
+    return {
+        collected_at: new Date().toISOString(),
+        gipity_version: cliVersion(),
+        node_version: process.versions.node,
+        os: { platform: process.platform, release: safe(() => release()), arch: process.arch },
+        cpu: { count: cores.length || undefined, model: cores[0]?.model?.trim() || undefined },
+        mem: { total: safe(() => totalmem()), free: safe(() => freemem()) },
+        load1: safe(() => Math.round(loadavg()[0] * 100) / 100),
+        uptime_s: safe(() => Math.round(uptime())),
+        disk: diskUsage(),
+        gpu,
+        agents: Object.keys(agents).length ? agents : undefined,
+        projects_local: localProjectCount(),
+    };
+}
+function safe(fn) {
+    try {
+        return fn();
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/relay/onboarding.js

@@ -12,12 +12,12 @@
  * All the non-interactive primitives live in `setup.ts` (`pairDevice`,
  * `startDaemon`, `installAutostart`); this module is only the prompts + copy.
  */
-import { hostname } from 'os';
+import { readFileSync } from 'node:fs';
 import { prompt, confirm } from '../utils.js';
 import { bold, brand, dim, success, error as clrError, muted } from '../colors.js';
 import * as state from './state.js';
 import { UnsupportedPlatformError } from './installers.js';
-import { pairDevice, startDaemon, installAutostart } from './setup.js';
+import { pairDevice, startDaemon, installAutostart, friendlyDeviceName } from './setup.js';
 /** Spawn a fresh `gipity relay run` detached from this process. Fire-and-forget.
  *  Re-exported from the shared `setup` core so existing importers (`claude.ts`)
  *  keep their import path. */
@@ -27,6 +27,21 @@ export const ensureDaemonRunning = startDaemon;
  * ended up enabled (or was already), `false` if the user declined or a step
  * failed. Non-interactive flows (e.g. `gipity claude -p`) must not call this.
  */
+/** True inside Windows Subsystem for Linux (either env marker or kernel
+ *  string). Used to explain autostart failures accurately - WSL ships without
+ *  a systemd user session unless the user opts in via /etc/wsl.conf. */
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)
+        return true;
+    try {
+        return /microsoft/i.test(readFileSync('/proc/version', 'utf-8'));
+    }
+    catch {
+        return false;
+    }
+}
 export async function runRelaySetup(opts) {
     const alreadyAnswered = state.getRelayEnabled() !== undefined;
     // `gipity claude` first-run: honor the user's prior choice and don't re-ask.
@@ -35,6 +50,36 @@ export async function runRelaySetup(opts) {
             ensureDaemonRunning();
         return state.isRelayEnabled();
     }
+    // We only ever REGISTER an unregistered machine. If this computer already has
+    // a device, re-running setup must not silently create a second one — nor
+    // quietly reuse the old name after asking for a new one (the original bug:
+    // you'd type a new name and it would still show the old one). Surface the
+    // existing registration plainly and point at revoke as the way to start over.
+    const existingDevice = state.getDevice();
+    if (existingDevice) {
+        // Keep setup's promise: leave the relay enabled and running.
+        state.setRelayEnabled(true);
+        if (!state.isPaused())
+            ensureDaemonRunning();
+        if (opts.mode === 'run-now') {
+            console.log(`  ${bold('This computer is already set up as a relay')}`);
+            console.log('');
+            console.log(`  ${success('Registered as')} ${bold(existingDevice.name)} ${muted(`(${existingDevice.guid})`)}`);
+            if (state.isPaused()) {
+                console.log(`  ${dim('The relay is paused — resume it with')} ${brand('gipity relay resume')}${dim('.')}`);
+            }
+            else {
+                console.log(`  ${dim('The relay is running. Open')} ${brand('gipity.ai')}${dim(' and type `/claude` to drive Claude Code here.')}`);
+            }
+            console.log('');
+            console.log(`  ${dim('To register this computer again — for example under a different name —')}`);
+            console.log(`  ${dim('unregister it first, then re-run setup:')}`);
+            console.log(`      ${brand('gipity relay revoke')}   ${dim('# unpairs this computer and removes the login service')}`);
+            console.log(`      ${brand('gipity setup')}          ${dim('# register it again (asks for a new name)')}`);
+            console.log('');
+        }
+        return true;
+    }
     // Header. `gipity setup` frames it as the deliberate action it is; the
     // `gipity claude` first-run frames it as an optional add-on it's offering.
     if (opts.mode === 'run-now') {
@@ -59,8 +104,8 @@ export async function runRelaySetup(opts) {
         console.log('');
         return false;
     }
-    // Device name - show hostname as the default; Enter accepts.
-    const defaultName = hostname() || 'my-pc';
+    // Device name - show a friendly default (owner + device kind); Enter accepts.
+    const defaultName = friendlyDeviceName();
     const rawName = await prompt(`  Device name [${bold(defaultName)}]: `);
     const name = (rawName || defaultName).trim();
     if (!name || name.length > 100) {
@@ -94,7 +139,18 @@ export async function runRelaySetup(opts) {
         try {
             const res = installAutostart();
             if (!res.ok) {
-                console.log(`  ${muted('Autostart install returned non-zero - you can run')} ${brand('gipity relay install')} ${muted('later.')}`);
+                if (isWsl()) {
+                    // WSL: `systemctl --user` fails unless systemd is enabled in
+                    // /etc/wsl.conf, so name the actual cause + the fix instead of a
+                    // generic non-zero. The relay itself is unaffected (it's already
+                    // running this session, and `gipity claude` restarts it).
+                    console.log(`  ${muted('Auto-start needs systemd, which this WSL distro has off. The relay still runs -')}`);
+                    console.log(`  ${muted('it started just now and `gipity claude` restarts it. For boot-time auto-start:')}`);
+                    console.log(`  ${muted('add [boot] systemd=true to /etc/wsl.conf, restart WSL, then run')} ${brand('gipity relay install')}${muted('.')}`);
+                }
+                else {
+                    console.log(`  ${muted('Autostart install returned non-zero - you can run')} ${brand('gipity relay install')} ${muted('later.')}`);
+                }
             }
             else {
                 console.log(`  ${success('Auto-start installed.')} ${dim(res.summary)}`);
@@ -109,6 +165,14 @@ export async function runRelaySetup(opts) {
             }
         }
     }
+    // Diagnostics consent - default on, clearly opt-out. Only ask once.
+    if (state.getDiagnosticsConsent() === undefined) {
+        const diag = await confirm('  Share anonymous diagnostics (CPU/GPU/memory/disk/versions) to improve reliability?', { default: 'yes' });
+        state.setDiagnosticsConsent(diag);
+        console.log(`  ${dim(diag
+            ? 'Thanks - no personal data or file paths are ever sent. Turn off anytime with `gipity relay diagnostics off`.'
+            : 'Diagnostics off. Turn on anytime with `gipity relay diagnostics on`.')}`);
+    }
     console.log('');
     console.log(`  ${success(`Registered as ${bold(device.name)} (${device.guid}).`)}`);
     console.log(`  ${dim('In the Gipity web CLI, type `/claude` to dispatch messages to this PC.')}`);