gipity 1.1.4 → 1.1.5

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/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);