gipity 1.1.4 → 1.1.6

package/dist/commands/status.js

@@ -4,7 +4,7 @@ import { join, resolve } from 'path';
 import { homedir } from 'os';
 import { getAuth, sessionExpired } from '../auth.js';
 import { get, usingEnvToken, ApiError } from '../api.js';
-import { getConfig, liveUrl } from '../config.js';
+import { getConfig, liveUrl, resolveApiBase } from '../config.js';
 import { brand, success, warning, muted, error as clrError } from '../colors.js';
 import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, setupClaudeHooks, ensureGipityPlugin, ensureGipityPluginInstalled, userScopeInstallState } from '../setup.js';
 import { flushBugQueue } from '../bug-queue.js';
@@ -39,15 +39,20 @@ function checkGipityPlugin() {
     const stale = missing.length === 1 && missing[0] === 'install' && install.exists;
     return { missing, ok: missing.length === 0, stale };
 }
+/** `account` is the server's `account_slug` for the authenticated identity
+ *  (only populated on 'ok' - the /users/me call that proved the probe also
+ *  returns it) - used for the ownership cross-check against the locally
+ *  cached project (bug cli#S2: a wrong-account session used to read as
+ *  fully healthy until a later command 404'd). */
 async function probeAuth(loggedIn) {
     if (!loggedIn && !usingEnvToken())
-        return 'none';
+        return { state: 'none', account: null };
     if (!usingEnvToken() && sessionExpired())
-        return 'expired';
+        return { state: 'expired', account: null };
     // Cap the probe well below the API layer's 60s request timeout - status is
     // a diagnostic command and must answer fast even when the network is dark.
-    const timeout = new Promise(res => setTimeout(() => res('unreachable'), 5000).unref?.());
-    const call = get('/users/me').then(() => 'ok', (err) => (err instanceof ApiError && err.statusCode === 401 ? 'rejected' : 'unreachable'));
+    const timeout = new Promise(res => setTimeout(() => res({ state: 'unreachable', account: null }), 5000).unref?.());
+    const call = get('/users/me').then((res) => ({ state: 'ok', account: res.data?.accountSlug ?? null }), (err) => ({ state: (err instanceof ApiError && err.statusCode === 401 ? 'rejected' : 'unreachable'), account: null }));
     return Promise.race([call, timeout]);
 }
 // `whoami` is the name agents reach for first when they want the signed-in
@@ -71,6 +76,12 @@ export const statusCommand = new Command('status')
     // is empty, which is the common case, so this stays a no-op most runs.
     const queueDelivered = (auth && !sessionExpired()) ? await flushBugQueue().catch(() => 0) : 0;
     const probe = await probeAuth(!!auth);
+    // RBAC lets a project be shared to a collaborator whose own account
+    // legitimately differs from the project owner's - so this is advisory,
+    // never a hard error. Only meaningful once a live 'ok' call has actually
+    // returned an account to compare against config.accountSlug.
+    const accountMismatch = probe.state === 'ok' && !!config && !!probe.account && probe.account !== config.accountSlug;
+    const apiBaseInUse = resolveApiBase();
     if (opts.json) {
         console.log(JSON.stringify({
             project: config ? {
@@ -78,17 +89,21 @@ export const statusCommand = new Command('status')
                 slug: config.projectSlug,
                 account: config.accountSlug,
                 apiBase: config.apiBase,
+                apiBaseInUse,
                 url: liveUrl(config),
             } : null,
             // `valid` reflects the refresh token (the real session) - access
             // tokens auto-renew, so their expiry must not read as "invalid".
             // `probe` is what one live call just proved: 'rejected' means every
             // authenticated command will fail even though `valid` reads true.
+            // 'mismatch' overrides 'ok' when the live account isn't the one that
+            // owns this project - `valid` still reads true (the token IS valid).
             auth: (auth || usingEnvToken()) ? {
                 email: auth?.email,
+                account: probe.account,
                 source: usingEnvToken() ? 'agent-token' : 'session',
-                valid: usingEnvToken() ? probe !== 'rejected' : !sessionExpired(),
-                probe,
+                valid: usingEnvToken() ? probe.state !== 'rejected' : !sessionExpired(),
+                probe: accountMismatch ? 'mismatch' : probe.state,
             } : null,
             plugin: hookCheck,
         }, null, 2));
@@ -102,28 +117,42 @@ export const statusCommand = new Command('status')
         console.log(`${muted('Account:')} ${config.accountSlug}`);
         console.log(`${muted('Live:')} ${liveUrl(config)}`);
         console.log(`${muted('API:')} ${config.apiBase}`);
+        // apiBase is only what THIS project recorded - resolveApiBase() is what
+        // every real request actually uses (it can diverge via GIPITY_API_BASE,
+        // --api-base, or a disallowed host being dropped to the default). Surface
+        // the divergence rather than silently trusting the recorded value.
+        if (apiBaseInUse !== config.apiBase) {
+            console.log(`${muted('API (in use):')} ${warning(apiBaseInUse)} ${muted('(overrides .gipity.json — GIPITY_API_BASE / --api-base / allowlist)')}`);
+        }
         if (config.agentGuid)
             console.log(`${muted('Agent:')} ${config.agentGuid}`);
     }
     if (usingEnvToken()) {
-        console.log(`${muted('Auth:')} ${probe === 'rejected'
+        console.log(`${muted('Auth:')} ${probe.state === 'rejected'
             ? warning('agent API token (GIPITY_TOKEN) rejected by the server — mint a new one: gipity skill read agent-deploy')
-            : success('agent API token (GIPITY_TOKEN)')}${probe === 'unreachable' ? ` ${muted('(unverified — API unreachable)')}` : ''}`);
+            : success('agent API token (GIPITY_TOKEN)')}${probe.state === 'unreachable' ? ` ${muted('(unverified — API unreachable)')}` : ''}`);
     }
     else if (!auth) {
         console.log(`${muted('Auth:')} ${warning('not logged in. Run: gipity login')}`);
     }
-    else if (probe === 'expired') {
+    else if (probe.state === 'expired') {
         console.log(`${muted('Auth:')} ${warning(`session expired for ${auth.email}. Run: gipity login (headless/CI: set GIPITY_TOKEN — gipity skill read agent-deploy)`)}`);
     }
-    else if (probe === 'rejected') {
+    else if (probe.state === 'rejected') {
         // Locally fresh but the server says no (refresh token rotated away or
         // revoked). Without the live probe this printed a green identity while
         // every authenticated command failed.
         console.log(`${muted('Auth:')} ${warning(`session for ${auth.email} was rejected by the server. Run: gipity login (headless/CI: set GIPITY_TOKEN — gipity skill read agent-deploy)`)}`);
     }
     else {
-        console.log(`${muted('Auth:')} ${success(auth.email)}${probe === 'unreachable' ? ` ${muted('(unverified — API unreachable)')}` : ''}`);
+        console.log(`${muted('Auth:')} ${success(auth.email)}${probe.state === 'unreachable' ? ` ${muted('(unverified — API unreachable)')}` : ''}`);
+    }
+    // Source-independent (session or GIPITY_TOKEN): a mismatch under an agent
+    // token is the same wrong-account class and must not be hidden inside the
+    // cascade above, which only special-cases 'rejected' for that source.
+    if (accountMismatch) {
+        console.log(`${muted('Account:')} ${warning(`logged-in account (${probe.account}) differs from this project's account (${config.accountSlug}). If you didn't expect this you may be logged into the wrong account — run: gipity login`)}`);
+        console.log(muted('(If this project was shared with you via gipity rbac, this is expected.)'));
     }
     if (queueDelivered > 0) {
         console.log(`${muted('Bug queue:')} ${success(`delivered ${queueDelivered} queued bug report${queueDelivered === 1 ? '' : 's'}`)}`);

package/dist/commands/storage.js

@@ -50,12 +50,12 @@ function printUsage(d) {
         console.log(`${bold('By project')} ${muted(scope)}`);
         for (const p of d.projects) {
             const name = p.projectName ?? '(no project)';
-            row(name.length > 16 ? `${name.slice(0, 15)}…` : name, formatBytes(p.liveBytes), `${p.liveFiles.toLocaleString()} files`);
+            row(name.length > 16 ? `${name.slice(0, 13)}...` : name, formatBytes(p.liveBytes), `${p.liveFiles.toLocaleString()} files`);
         }
         if (hidden > 0) {
             const shownBytes = d.projects.reduce((n, p) => n + p.liveBytes, 0);
             const shownFiles = d.projects.reduce((n, p) => n + p.liveFiles, 0);
-            row(`…and ${hidden.toLocaleString()} more`, formatBytes(totals.liveBytes - shownBytes), `${(totals.liveFiles - shownFiles).toLocaleString()} files`);
+            row(`...and ${hidden.toLocaleString()} more`, formatBytes(totals.liveBytes - shownBytes), `${(totals.liveFiles - shownFiles).toLocaleString()} files`);
         }
     }
     const r = d.versionRetention;

package/dist/commands/sync.js

@@ -1,7 +1,10 @@
 import { Command } from 'commander';
+import { dirname } from 'node:path';
 import { sync } from '../sync.js';
 import { createProgressReporter } from '../progress.js';
 import { error as clrError, muted } from '../colors.js';
+import { findWindowsTwinProject, isWsl, wslPathToWindows } from '../utils.js';
+import { getConfigPath } from '../config.js';
 export const syncCommand = new Command('sync')
     .description('Sync files')
     .addHelpText('after', '\nAdd a .gipityignore at the project root to exclude paths (gitignore-style).')
@@ -30,6 +33,18 @@ export const syncCommand = new Command('sync')
             // local). Surface that here as a helpful hint - not a red error - with
             // the one command that resolves it. Only `gipity sync` shows this;
             // deploy/test/sandbox stay silent (their internal sync defers quietly).
+            // WSL trap: a same-named folder under C:\Users\...\GipityProjects looks
+            // like "the project" from Windows Explorer, but files dropped there
+            // never sync. When a twin exists, say so - "Up to date." alone reads as
+            // "your new files are in" when they're sitting on the Windows side.
+            if (isWsl()) {
+                const configPath = getConfigPath();
+                const twin = configPath ? findWindowsTwinProject(dirname(configPath)) : null;
+                if (twin) {
+                    console.log(muted(`\nNote: a Windows-side copy of this project exists at ${wslPathToWindows(twin)} and is NOT synced. ` +
+                        `If you added files there, move them into this folder so they sync.`));
+                }
+            }
             if (result.deferredDeletes > 0) {
                 console.log(muted(`\n${result.deferredDeletes} file${result.deferredDeletes > 1 ? 's' : ''} on Gipity ` +
                     `${result.deferredDeletes > 1 ? 'are' : 'is'} not present locally and ${result.deferredDeletes > 1 ? 'were' : 'was'} left untouched. ` +

package/dist/commands/test.js

@@ -149,7 +149,7 @@ async function pollTestStatus(projectGuid, runGuid, opts) {
                     const tally = data.passed + data.failed > 0
                         ? ` (${data.passed} passed${data.failed > 0 ? `, ${data.failed} failed` : ''} so far)`
                         : '';
-                    console.log(muted(`  … still running — ${progress}${tally}, ${elapsed}s elapsed`));
+                    console.log(muted(`  ... still running - ${progress}${tally}, ${elapsed}s elapsed`));
                     if (now - startTime >= LONG_RUN_MS && !longRunHintShown) {
                         longRunHintShown = true;
                         console.log(muted('  Note: progressing, not hung. LLM-backed tests can take minutes. To verify one function fast, use `gipity fn call <name>`; narrow this suite with `gipity test <path>`.'));

package/dist/commands/token.js

@@ -4,7 +4,12 @@ import { bold, muted, success, warning } from '../colors.js';
 import { run, printList } from '../helpers/index.js';
 export const tokenCommand = new Command('token')
     .description('Manage API tokens')
-    .addHelpText('after', '\nLong-lived agent API tokens (gip_at_*) for headless agents and CI.');
+    .addHelpText('after', `
+Long-lived agent API tokens (gip_at_*) for headless agents and CI - they drive
+the gipity CLI as YOU.
+
+To let a script or cron write to one app instead, mint a project API key:
+gipity key create "my script" --role editor (sent as X-Api-Key).`);
 const fmtDate = (d) => (d ? new Date(d).toLocaleDateString() : 'never');
 tokenCommand
     .command('create')

package/dist/commands/uninstall.js

@@ -19,7 +19,7 @@ import { confirm, getAutoConfirm } from '../utils.js';
 import { bold, brand, dim, success, error as clrError, muted } from '../colors.js';
 import * as relayState from '../relay/state.js';
 import { planFor, UnsupportedPlatformError } from '../relay/installers.js';
-import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, stripGipityHooks, grokInstallState, agentSkillsState, AGENTS_SKILLS_DIR } from '../setup.js';
+import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, stripGipityHooks, grokInstallState, agentSkillsState, AGENTS_SKILLS_DIR, agySkillsState, AGY_SKILLS_DIR, } from '../setup.js';
 /** Remove Gipity's entries from the user-scope Claude Code settings: the
  *  plugin enablement, the marketplace registration, and any legacy hook
  *  blocks older CLI versions wrote there. Surgical - everything else in the
@@ -240,6 +240,19 @@ export const uninstallCommand = new Command('uninstall')
         }
         console.log(`${success(`Removed ${agentSkills.skills.length} Gipity skills from ~/.agents/skills.`)}`);
     }
+    // 4c. Remove the skills the CLI copied into Antigravity's own global
+    //     skill root (~/.gemini/config/skills - a different directory from
+    //     Codex's ~/.agents/skills, see setup.ts).
+    const agySkills = agySkillsState();
+    if (agySkills.skills.length) {
+        for (const name of agySkills.skills) {
+            try {
+                rmSync(join(AGY_SKILLS_DIR, name), { recursive: true, force: true });
+            }
+            catch { /* best-effort */ }
+        }
+        console.log(`${success(`Removed ${agySkills.skills.length} Gipity skills from ~/.gemini/config/skills.`)}`);
+    }
     // 5. Wipe ~/.gipity/ (this also removes the agent-hooks scripts and the
     //    agent-skills manifest, which live under it).
     if (existsSync(gipityDir)) {

package/dist/commands/upload.js

@@ -65,7 +65,7 @@ token-signed serve url instead (reachable only by holders of the url).`)
     };
     const data = opts.json
         ? await doUpload()
-        : await withSpinner(`Uploading ${filename} (${formatSize(size)})…`, doUpload, { done: null });
+        : await withSpinner(`Uploading ${filename} (${formatSize(size)})...`, doUpload, { done: null });
     if (opts.json) {
         console.log(JSON.stringify(data));
         return;

package/dist/commands/workflow.js

@@ -186,7 +186,7 @@ workflowCommand
 }));
 workflowCommand
     .command('runs <name> [runGuid]')
-    .description('List recent runs, or pass a run guid (wr_…) to see that run\'s per-step outputs')
+    .description('List recent runs, or pass a run guid (wr_...) to see that run\'s per-step outputs')
     .option('--json', 'Output as JSON')
     .action((name, runGuid, _opts, cmd) => run('Runs', async () => {
     const opts = mergedOpts(cmd);

package/dist/hooks/capture-runner.js

@@ -51,6 +51,7 @@ import { getConfig } from '../config.js';
 import { parseTranscript as parseClaudeTranscript, } from '../capture/sources/claude-code.js';
 import { parseTranscript as parseCodexTranscript } from '../capture/sources/codex.js';
 import { parseTranscript as parseGrokTranscript } from '../capture/sources/grok.js';
+import { parseTranscript as parseAgyTranscript } from '../capture/sources/agy.js';
 const CAPTURE_DIR = join(homedir(), '.gipity', 'capture-state');
 const INGEST_BATCH_MAX = 100; // server caps at 200; stay comfortably under
 export const CAPTURE_SOURCES = {
@@ -77,6 +78,14 @@ export const CAPTURE_SOURCES = {
             return join(homedir(), '.grok', 'sessions', encodeURIComponent(cwd), hook.session_id, 'chat_history.jsonl');
         },
     },
+    agy: {
+        serverSource: 'agy',
+        displayName: 'Antigravity',
+        // agy hook payloads always carry transcriptPath directly (no derivation
+        // needed, unlike Grok) - the agy-specific hook wrapper normalizes it into
+        // this HookInput's transcript_path before invoking this runner.
+        parse: (content, afterUuid, hook) => parseAgyTranscript(content, afterUuid, { conversationId: hook.session_id }),
+    },
 };
 // PostToolUse fires after every tool call. We flush on it so a session that is
 // killed/crashes mid-run (e.g. a long headless `gipity claude -p` build that
@@ -430,9 +439,10 @@ async function handleSessionEnd(convGuid, src, hook) {
     if (hook.session_id)
         deleteSessionMap(hook.session_id);
 }
-// Codex has no SessionEnd hook, so its capture-state/session-map files are
-// never cleaned by handleSessionEnd. Sweep anything stale on the way through
-// - the files are tiny, so a generous TTL is fine; a live session's state is
+// Codex and agy have no SessionEnd-equivalent hook, so their capture-state/
+// session-map files are never cleaned by handleSessionEnd. Sweep anything
+// stale on the way through - the files are tiny, so a generous TTL is fine; a
+// live session's state is
 // rewritten on every flush and never gets this old.
 const STATE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 function sweepStaleState() {
@@ -455,8 +465,10 @@ function sweepStaleState() {
 }
 /** Normalize a raw hook payload to snake_case HookInput. Claude Code and
  *  Codex deliver snake_case (`session_id`, `transcript_path`, `cwd`); Grok
- *  Build delivers camelCase (`sessionId`, `hookEventName`, …). Accept both
- *  so one runner serves every harness. */
+ *  Build delivers camelCase (`sessionId`, `hookEventName`, …); agy calls its
+ *  session id `conversationId` (its own hook payload has no session/cwd/event
+ *  fields under any other name - see cli/src/agents/agy.ts). Accept all of
+ *  these so one runner serves every harness. */
 export function normalizeHookInput(raw) {
     if (!raw || typeof raw !== 'object')
         return {};
@@ -469,7 +481,7 @@ export function normalizeHookInput(raw) {
         return undefined;
     };
     const hook = {
-        session_id: pick('session_id', 'sessionId'),
+        session_id: pick('session_id', 'sessionId', 'conversationId'),
         transcript_path: pick('transcript_path', 'transcriptPath'),
         cwd: pick('cwd', 'workingDirectory'),
         hook_event_name: pick('hook_event_name', 'hookEventName'),
@@ -509,8 +521,8 @@ async function main() {
         if (derived)
             hook.transcript_path = derived;
     }
-    // Opportunistic hygiene: Codex never fires session-end, so its state
-    // files are TTL-swept instead of deleted at end-of-session.
+    // Opportunistic hygiene: Codex and agy never fire session-end, so their
+    // state files are TTL-swept instead of deleted at end-of-session.
     sweepStaleState();
     const convGuid = await resolveConvGuid(hook, src.serverSource);
     if (!convGuid)