gipity 1.0.410 → 1.0.412

package/dist/commands/claude.js

@@ -4,15 +4,16 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, readdir
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { resolveCommand, spawnCommand } from '../platform.js';
-import { getAuth, saveAuth, sessionExpired, accessTokenExpired, refreshTokenIfNeeded } from '../auth.js';
-import { get, post, publicPost, ApiError, getAccountSlug } from '../api.js';
+import { getAuth, sessionExpired, accessTokenExpired, refreshTokenIfNeeded } from '../auth.js';
+import { get, post, ApiError, getAccountSlug } from '../api.js';
+import { interactiveLogin } from '../login-flow.js';
 import { getConfig, saveConfigAt, clearConfigCache, getApiBaseOverride, DEFAULT_API_BASE, getConfigPath } from '../config.js';
 import { sync } from '../sync.js';
 import { slugify, setupClaudeHooks, ensureGipityPluginInstalled, setupClaudeMd, setupAgentsMd, setupGitignore, DEFAULT_SYNC_IGNORE, isSyncIgnored } from '../setup.js';
 import { buildProjectContextBlock as buildProjectContextBlockText, buildNewProjectPrompt, buildResumeWrap, buildFreshWrap, } from '../prompts.js';
 import * as relayState from '../relay/state.js';
 import { maybeOfferRelayOn, ensureDaemonRunning } from '../relay/onboarding.js';
-import { prompt, pickOne, decodeJwtExp, confirm } from '../utils.js';
+import { prompt, pickOne, confirm } from '../utils.js';
 import { brand, bold, info, success, warning, error as clrError, muted } from '../colors.js';
 import { createProgressReporter } from '../progress.js';
 import { printBanner } from '../banner.js';
@@ -118,33 +119,9 @@ async function buildProjectContextBlock(opts) {
     const stats = await fetchProjectStats(opts.projectGuid, opts.cwd);
     return buildProjectContextBlockText({ ...opts, ...stats });
 }
-/** Interactive email+code login flow. Used on first login and when the
- *  server returns 401 mid-command (session expired). Writes the new auth
- *  to disk and returns it. */
-async function interactiveLogin() {
-    const email = await prompt('  Email: ');
-    if (!email) {
-        console.error(`\n  ${clrError('Email required.')}`);
-        process.exit(1);
-    }
-    await publicPost('/auth/login', { email });
-    console.log('  Check your email for a 6-digit code.\n');
-    const code = await prompt('  Code: ');
-    if (!code) {
-        console.error(`\n  ${clrError('Code required.')}`);
-        process.exit(1);
-    }
-    const res = await publicPost('/auth/verify', { email, code });
-    const exp = decodeJwtExp(res.accessToken);
-    if (!exp) {
-        console.error(`\n  ${clrError('Invalid token received.')}`);
-        process.exit(1);
-    }
-    const expiresAt = new Date(exp * 1000).toISOString();
-    saveAuth({ accessToken: res.accessToken, refreshToken: res.refreshToken, email, expiresAt });
-    console.log(`  ${success(`Logged in (${email}).`)}`);
-    return getAuth();
-}
+// Interactive email+code login now lives in `login-flow.ts` (shared with
+// `gipity setup`). Used on first login and when the server returns 401
+// mid-command (session expired).
 // First-run relay onboarding now lives in `relay/onboarding.ts`
 // (`maybeOfferRelayOn`). `gipity claude` invokes it after project
 // selection, and also calls `ensureDaemonRunning` unconditionally before
@@ -310,26 +287,42 @@ export const claudeCommand = new Command('claude')
         // saved session's expiry is irrelevant when one is set — never re-login or
         // warn about expiry in that case.
         const hasEnvToken = Boolean(process.env.GIPITY_TOKEN?.trim());
-        // For an interactive saved-session run, renew the access token UP FRONT so
-        // the login line we're about to print is actually true. A saved session
-        // can look valid locally (refresh token not past its JWT expiry, so
-        // sessionExpired() is false) yet be dead on the server — most often because
-        // a sibling process sharing this auth.json already consumed the single-use
-        // refresh token (GipRunner runs many gipity processes against one auth dir).
-        // refreshTokenIfNeeded() attempts the rotation here; if it fails, the
-        // access token stays expired and accessTokenExpired() catches it below.
-        if (auth && !hasEnvToken && !nonInteractive && !sessionExpired()) {
+        // Renew the access token UP FRONT so the login line we're about to print is
+        // actually true — in BOTH interactive and headless/relay runs. A saved
+        // session can look valid locally (refresh token not past its 7-day JWT
+        // expiry, so sessionExpired() is false) yet be dead on the server: a sibling
+        // process sharing this auth.json already consumed the single-use refresh
+        // token (GipRunner and the relay run many gipity processes against one auth
+        // dir), the user logged in elsewhere, or — in dev — the server's session
+        // store was flushed/restarted. refreshTokenIfNeeded() round-trips to the
+        // server and adopts any freshly-rotated token; if it fails, the access token
+        // stays expired and accessTokenExpired() catches it below. Headless runs
+        // USED to skip this and print "Logged in" off the cheap local check alone —
+        // then the very next sync would 401 with "Session expired" and the relay
+        // would run Claude anyway against a tree it could neither pull nor push.
+        if (auth && !hasEnvToken && !sessionExpired()) {
             await refreshTokenIfNeeded();
             auth = getAuth();
         }
         // Re-login is genuinely required when the refresh token has lapsed, OR the
         // proactive renewal above could not produce a still-valid access token
-        // (refresh token rejected/rotated away). The access-token check is gated to
-        // interactive runs: headless runs can't prompt, and their downstream API
-        // call renews the token itself. Never triggered while a GIPITY_TOKEN env
+        // (refresh token rejected — rotated away, revoked, or the server forgot it).
+        // Checked identically for headless and interactive now: a dead session must
+        // not silently proceed in either. Never triggered while a GIPITY_TOKEN env
         // token is supplying auth.
         const reloginRequired = auth != null && !hasEnvToken &&
-            (sessionExpired() || (!nonInteractive && accessTokenExpired()));
+            (sessionExpired() || accessTokenExpired());
+        if (auth && reloginRequired && nonInteractive) {
+            // Headless (relay dispatch, CI): we can't prompt for a re-login, and
+            // running Claude now would work against a project tree we can neither pull
+            // nor push (every authenticated call 401s). Fail fast with the actionable
+            // message instead of printing "Logged in" and silently losing the user's
+            // changes. The relay surfaces this stderr line to the web CLI as the
+            // dispatch error, so the user sees "run: gipity login" instead of a run
+            // that appeared to work but synced nothing.
+            console.error(`  ${clrError('Your Gipity session has expired. Run: gipity login')}`);
+            process.exit(1);
+        }
         if (auth && reloginRequired) {
             // The saved session is dead (refresh token lapsed, or rotated away by a
             // sibling process), so the first API call below would 401. Re-login up

package/dist/commands/credits.js

@@ -145,13 +145,17 @@ creditsCommand
     // 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([
+    // Plans + subscription are required; credit packs are best-effort - the plan
+    // comparison must still render if /credits/products is unavailable (e.g.
+    // credit packs aren't configured in this environment).
+    const [plansRes, subRes] = await Promise.all([
         get('/plans'),
-        get('/credits/products'),
         get('/credits/subscription'),
     ]);
+    const products = await get('/credits/products')
+        .then(r => r.data).catch(() => []);
     if (opts.json) {
-        console.log(JSON.stringify({ currentTier: subRes.data.tier, plans: plansRes.data, products: productsRes.data }));
+        console.log(JSON.stringify({ currentTier: subRes.data.tier, plans: plansRes.data, products }));
         return;
     }
     const currentTier = subRes.data.tier;
@@ -171,7 +175,7 @@ creditsCommand
         renderLimits(plan.limits, '      ');
         console.log('');
     }
-    const packs = productsRes.data.filter(p => p.type === 'one_time');
+    const packs = products.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) {
@@ -195,11 +199,12 @@ creditsCommand
     // 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 subRes = await get('/credits/subscription');
+    // Products are best-effort: if the catalog is unavailable we can't build a
+    // direct checkout link, so we fall back to the pricing page below rather
+    // than erroring out.
+    const products = await get('/credits/products')
+        .then(r => r.data).catch(() => []);
     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

package/dist/commands/setup.js

@@ -0,0 +1,59 @@
+/**
+ * `gipity setup` — get this computer ready as a relay, then stop.
+ *
+ * Runs the SAME first steps as `gipity claude` (log in, then pair + start the
+ * relay + install the OS login service) but does NOT pick a project or launch
+ * Claude Code. For the user who wants their machine available as a relay in the
+ * web CLI without being dropped into a coding session.
+ *
+ * Shares one implementation with `gipity claude`: auth via `login-flow.ts`,
+ * relay setup via `relay/onboarding.ts` (`runRelaySetup`). Nothing to maintain
+ * twice.
+ */
+import { Command } from 'commander';
+import { getAuth, sessionExpired, refreshTokenIfNeeded } from '../auth.js';
+import { interactiveLogin } from '../login-flow.js';
+import { runRelaySetup } from '../relay/onboarding.js';
+import * as relayState from '../relay/state.js';
+import { bold, brand, success, muted, error as clrError } from '../colors.js';
+export const setupCommand = new Command('setup')
+    .description('Set up this computer as a relay (no project, no launch)')
+    .action(async () => {
+    try {
+        console.log('');
+        console.log(`  ${bold('Gipity setup')} ${muted('- get this computer ready as a relay')}`);
+        console.log('');
+        // ── Step 1: Auth ──────────────────────────────────────────────────
+        let auth = getAuth();
+        if (auth && !sessionExpired()) {
+            await refreshTokenIfNeeded();
+            auth = getAuth();
+            console.log(`  Logged in (${auth?.email}).`);
+        }
+        else {
+            if (auth)
+                console.log(`  ${muted('Your session expired. Let\'s sign you back in.')}\n`);
+            else
+                console.log('  Let\'s get you logged in.\n');
+            auth = await interactiveLogin();
+        }
+        console.log('');
+        // ── Step 2: Relay setup (always run — the user asked for it) ───────
+        const enabled = await runRelaySetup({ mode: 'run-now' });
+        // ── Step 3: Done. No project, no Claude Code launch. ──────────────
+        if (enabled) {
+            const running = relayState.isRelayEnabled() && !relayState.isPaused();
+            console.log(`  ${success('Done')} — your relay ${running ? 'is running in the background' : 'is set up'} and will start with your computer.`);
+            console.log(`  ${muted('Open')} ${brand('gipity.ai')} ${muted('and start a chat to drive Claude Code here. Manage it with `gipity relay status`.')}`);
+        }
+        else {
+            console.log(`  ${muted('No relay set up. Run `gipity setup` again anytime, or `gipity claude` to build with Gipity.')}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error(`\n  ${clrError(`Error: ${err.message}`)}`);
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=setup.js.map

package/dist/hooks/capture-runner.js

@@ -7,14 +7,14 @@
  *
  * Not a user-facing `gipity` subcommand by design: users never invoke
  * this directly. The Gipity Claude Code plugin's capture hook script
- * (claude-plugin hooks/scripts/capture.cjs) resolves this file inside the
+ * (skills repo hooks/scripts/capture.cjs) resolves this file inside the
  * installed CLI at fire time and runs it - so the capture logic versions
  * with the CLI, not the plugin.
  *
  * Usage:
  *   node capture-runner.js <source> <event>
  *   source: 'claude-code' (today) | future: 'codex', …
- *   event:  'session-start' | 'stop' | 'subagent-stop' | 'session-end' | 'post-tool-use'
+ *   event:  'session-start' | 'stop' | 'subagent-stop' | 'session-end' | 'post-tool-use' | 'pre-compact'
  *
  * Graceful no-ops (exit 0 silently):
  *   - GIPITY_CONVERSATION_GUID env var unset (hook fired from a bare
@@ -304,6 +304,19 @@ async function main() {
             case 'session-end':
                 await handleSessionEnd(convGuid, hook, source);
                 break;
+            case 'pre-compact': {
+                // Flush the transcript tail BEFORE compaction rewrites it (the
+                // watermark replay after a rewrite relies on server dedup, but
+                // flushing first keeps ordering clean), then record the boundary.
+                await handleStopFamily(convGuid, hook, false);
+                const trigger = typeof hook.trigger === 'string' ? hook.trigger : 'auto';
+                await postEntries(convGuid, [{
+                        kind: 'compact',
+                        trigger,
+                        source_uuid: `${hook.session_id ?? 'unknown'}-compact-${Date.now()}`,
+                    }]);
+                break;
+            }
             default:
                 return; // unknown event - silent no-op
         }

package/dist/index.js

@@ -52,6 +52,7 @@ import { locationCommand } from './commands/location.js';
 import { doctorCommand } from './commands/doctor.js';
 import { updateCommand } from './commands/update.js';
 import { relayCommand } from './commands/relay.js';
+import { setupCommand } from './commands/setup.js';
 import { uninstallCommand } from './commands/uninstall.js';
 import { approvalCommand } from './commands/approval.js';
 import { gmailCommand } from './commands/gmail.js';
@@ -125,7 +126,7 @@ const program = new Command();
 program.enablePositionalOptions();
 // ── Command groups (logical ordering within each) ──────────────────────
 const commonGroup = [skillCommand, projectCommand, addCommand, removeCommand, deployCommand];
-const connectGroup = [claudeCommand, relayCommand];
+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];
@@ -180,6 +181,7 @@ program.configureHelp({
         lines.push(bold('Quick start:'));
         lines.push(`  ${brand('gipity login')}    ${dim('- authenticate first if you haven\'t already')}`);
         lines.push(`  ${brand('gipity init')}     ${dim('- link this dir + write CLAUDE.md/AGENTS.md primers for your AI tool')}`);
+        lines.push(`  ${brand('gipity setup')}    ${dim('- set up this computer as a relay to drive from gipity.ai (no launch)')}`);
         lines.push(`  ${brand('gipity claude')}   ${dim('- or launch Claude Code with Gipity tools wired in')}`);
         lines.push('');
         lines.push(bold('Usage:'));

package/dist/login-flow.js

@@ -0,0 +1,42 @@
+/**
+ * Interactive email+code login, shared by every command that may need to log a
+ * user in mid-run (`gipity claude`, `gipity setup`). Kept in one place so the
+ * prompts, indentation, and token handling never drift between entry points.
+ *
+ * Distinct from `commands/login.ts` (the standalone `gipity login`, which also
+ * supports non-interactive `--email/--code`): this variant is the two-space
+ * indented, always-interactive flow used as a sub-step of a larger command, and
+ * it returns the fresh `AuthData` instead of exiting.
+ */
+import { publicPost } from './api.js';
+import { getAuth, saveAuth } from './auth.js';
+import { prompt, decodeJwtExp } from './utils.js';
+import { success, error as clrError } from './colors.js';
+/** Prompt for email + 6-digit code, persist the tokens, and return the new
+ *  auth. Exits the process on empty input or a bad token (the caller can't
+ *  proceed without a session). */
+export async function interactiveLogin() {
+    const email = await prompt('  Email: ');
+    if (!email) {
+        console.error(`\n  ${clrError('Email required.')}`);
+        process.exit(1);
+    }
+    await publicPost('/auth/login', { email });
+    console.log('  Check your email for a 6-digit code.\n');
+    const code = await prompt('  Code: ');
+    if (!code) {
+        console.error(`\n  ${clrError('Code required.')}`);
+        process.exit(1);
+    }
+    const res = await publicPost('/auth/verify', { email, code });
+    const exp = decodeJwtExp(res.accessToken);
+    if (!exp) {
+        console.error(`\n  ${clrError('Invalid token received.')}`);
+        process.exit(1);
+    }
+    const expiresAt = new Date(exp * 1000).toISOString();
+    saveAuth({ accessToken: res.accessToken, refreshToken: res.refreshToken, email, expiresAt });
+    console.log(`  ${success(`Logged in (${email}).`)}`);
+    return getAuth();
+}
+//# sourceMappingURL=login-flow.js.map