gitnexushub 0.2.12 → 0.4.0

package/dist/editors/windsurf.js

@@ -9,10 +9,15 @@ import path from 'path';
 import fs from 'fs/promises';
 import { readJsonFile, writeJsonFile } from '../utils.js';
 import { HUB_SKILLS } from '../content.js';
+import { computeFingerprint, getDeviceName } from '../fingerprint.js';
 function getMcpConfig(hubUrl, token) {
     return {
         serverUrl: `${hubUrl}/mcp`,
-        headers: { Authorization: `Bearer ${token}` },
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'X-Device-Fingerprint': computeFingerprint(),
+            'X-Device-Name': getDeviceName(),
+        },
     };
 }
 async function configure(hubUrl, token) {
@@ -25,7 +30,11 @@ async function configure(hubUrl, token) {
         const overrodeCli = !!(existing.mcpServers.gitnexus && 'command' in existing.mcpServers.gitnexus);
         existing.mcpServers.gitnexus = getMcpConfig(hubUrl, token);
         await writeJsonFile(mcpPath, existing);
-        return { success: true, message: 'MCP configured in ~/.codeium/windsurf/mcp_config.json', overrodeCli };
+        return {
+            success: true,
+            message: 'MCP configured in ~/.codeium/windsurf/mcp_config.json',
+            overrodeCli,
+        };
     }
     catch (err) {
         return { success: false, message: `Failed: ${err.message}` };
@@ -69,7 +78,9 @@ async function removeSkills() {
             await fs.rm(path.join(skillsDir, name), { recursive: true, force: true });
             removed++;
         }
-        catch { /* already gone */ }
+        catch {
+            /* already gone */
+        }
     }
     return removed;
 }

package/dist/fingerprint.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Device Fingerprint
+ *
+ * Computes a stable fingerprint for the current device.
+ * Used to bind device tokens to specific machines.
+ * Same algorithm as gitnexus/src/cli/auth.ts:computeFingerprint().
+ */
+/** SHA-256 hash of hostname:username:platform:arch, truncated to 16 hex chars. */
+export declare function computeFingerprint(): string;
+/** Human-readable device name: USER@HOSTNAME */
+export declare function getDeviceName(): string;

package/dist/fingerprint.js

@@ -0,0 +1,18 @@
+/**
+ * Device Fingerprint
+ *
+ * Computes a stable fingerprint for the current device.
+ * Used to bind device tokens to specific machines.
+ * Same algorithm as gitnexus/src/cli/auth.ts:computeFingerprint().
+ */
+import os from 'os';
+import crypto from 'crypto';
+/** SHA-256 hash of hostname:username:platform:arch, truncated to 16 hex chars. */
+export function computeFingerprint() {
+    const identity = `${os.hostname()}:${os.userInfo().username}:${os.platform()}:${os.arch()}`;
+    return crypto.createHash('sha256').update(identity).digest('hex').slice(0, 16);
+}
+/** Human-readable device name: USER@HOSTNAME */
+export function getDeviceName() {
+    return `${os.userInfo().username}@${os.hostname()}`;
+}

package/dist/hooks-installer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Per-editor hook installers.
+ *
+ * Writes idempotent editor-specific hook config files that point at
+ * the shipped gitnexus-enterprise-hook.cjs script. Called from the
+ * `gnx connect` flow after the MCP config is written.
+ */
+export interface InstallOptions {
+    /** Defaults to os.homedir(). Injectable for tests. */
+    homeDir?: string;
+    /** Absolute path to the shipped hook script. */
+    hookScriptPath: string;
+}
+/**
+ * Install the Claude Code PreToolUse + PostToolUse hooks.
+ * Returns the absolute path to the written hooks.json.
+ */
+export declare function installClaudeCodeHook(opts: InstallOptions): Promise<string>;
+/**
+ * Install the Cursor beforeShellExecution hook.
+ * Returns the absolute path to the written hooks.json.
+ */
+export declare function installCursorHook(opts: InstallOptions): Promise<string>;
+/**
+ * Install the OpenCode plugin stub.
+ * Returns the absolute path to the written TypeScript file.
+ *
+ * The plugin is currently a stub — the actual tool.before / tool.after
+ * wiring delegating to gitnexus-enterprise-hook.cjs will be filled in
+ * when we have concrete users on OpenCode. For M4.2 we write the file
+ * so gnx connect reports success and the user has a template to extend.
+ */
+export declare function installOpenCodeHook(opts: InstallOptions): Promise<string>;

package/dist/hooks-installer.js

@@ -0,0 +1,114 @@
+/**
+ * Per-editor hook installers.
+ *
+ * Writes idempotent editor-specific hook config files that point at
+ * the shipped gitnexus-enterprise-hook.cjs script. Called from the
+ * `gnx connect` flow after the MCP config is written.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+function getHome(opts) {
+    return opts.homeDir ?? os.homedir();
+}
+async function writeJsonIdempotent(filePath, obj) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const body = JSON.stringify(obj, null, 2) + '\n';
+    await fs.writeFile(filePath, body);
+}
+/**
+ * Install the Claude Code PreToolUse + PostToolUse hooks.
+ * Returns the absolute path to the written hooks.json.
+ */
+export async function installClaudeCodeHook(opts) {
+    const home = getHome(opts);
+    const hooksDir = path.join(home, '.claude', 'plugins', 'gitnexus-enterprise', 'hooks');
+    const hooksJsonPath = path.join(hooksDir, 'hooks.json');
+    // Double-quote the absolute path so shell splitting doesn't break
+    // when the install dir contains a space (e.g. Windows profiles at
+    // `C:\Users\John Doe\...`). The hook spec is a shell-style command
+    // string, not an argv array, so quoting is the only knob available.
+    const quotedScriptPath = `"${opts.hookScriptPath}"`;
+    const config = {
+        hooks: {
+            PreToolUse: [
+                {
+                    matcher: 'Grep|Glob|Bash',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `node ${quotedScriptPath}`,
+                            timeout: 5,
+                        },
+                    ],
+                },
+            ],
+            PostToolUse: [
+                {
+                    matcher: 'Bash',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `node ${quotedScriptPath}`,
+                            timeout: 5,
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+    await writeJsonIdempotent(hooksJsonPath, config);
+    return hooksJsonPath;
+}
+/**
+ * Install the Cursor beforeShellExecution hook.
+ * Returns the absolute path to the written hooks.json.
+ */
+export async function installCursorHook(opts) {
+    const home = getHome(opts);
+    const hooksJsonPath = path.join(home, '.cursor', 'hooks.json');
+    // Same shell-quoting rationale as installClaudeCodeHook — the
+    // command is a shell string, not argv, so the absolute path must
+    // be quoted to survive spaces.
+    const config = {
+        beforeShellExecution: {
+            command: `node "${opts.hookScriptPath}"`,
+            timeout: 5000,
+        },
+    };
+    await writeJsonIdempotent(hooksJsonPath, config);
+    return hooksJsonPath;
+}
+/**
+ * Install the OpenCode plugin stub.
+ * Returns the absolute path to the written TypeScript file.
+ *
+ * The plugin is currently a stub — the actual tool.before / tool.after
+ * wiring delegating to gitnexus-enterprise-hook.cjs will be filled in
+ * when we have concrete users on OpenCode. For M4.2 we write the file
+ * so gnx connect reports success and the user has a template to extend.
+ */
+export async function installOpenCodeHook(opts) {
+    const home = getHome(opts);
+    const pluginDir = path.join(home, '.opencode', 'plugin');
+    const pluginPath = path.join(pluginDir, 'gitnexus-enterprise.ts');
+    const content = `// GitNexus Enterprise OpenCode plugin
+// Stub — delegates to gitnexus-enterprise-hook.cjs via child process.
+// Hook script: ${opts.hookScriptPath}
+
+export default {
+  async toolBefore(ctx: { tool: string }) {
+    if (!['Grep', 'Glob', 'Bash'].includes(ctx.tool)) return;
+    // TODO: spawn gitnexus-enterprise-hook.cjs with the tool context on stdin
+    //       and forward additionalContext from stdout.
+  },
+  async toolAfter(ctx: { tool: string }) {
+    if (ctx.tool !== 'Bash') return;
+    // TODO: spawn gitnexus-enterprise-hook.cjs for PostToolUse staleness check
+  },
+};
+`;
+    await fs.mkdir(pluginDir, { recursive: true });
+    await fs.writeFile(pluginPath, content);
+    return pluginPath;
+}

package/dist/index.js

@@ -12,23 +12,12 @@ import { Command } from 'commander';
 import pc from 'picocolors';
 const require = createRequire(import.meta.url);
 const PKG_VERSION = require('../package.json').version;
-import { loadConfig, saveConfig, clearConfig } from './config.js';
-import { HubAPI } from './api.js';
-import { isGitRepo, getGitRemoteUrl, parseGitRemote, matchRepo } from './project.js';
-import { writeProjectContext, removeProjectContext } from './context.js';
-import { generateConnectContext } from './content.js';
-import { detectInstalledEditors } from './editors/detect.js';
-import { cursorEditor } from './editors/cursor.js';
-import { windsurfEditor } from './editors/windsurf.js';
-import { opencodeEditor } from './editors/opencode.js';
-import { claudeCodeEditor } from './editors/claude-code.js';
-const DEFAULT_HUB_URL = process.env.GITNEXUS_HUB_URL || 'https://gitnexus-enterprise-production.up.railway.app';
-const EDITORS = {
-    'claude-code': claudeCodeEditor,
-    cursor: cursorEditor,
-    windsurf: windsurfEditor,
-    opencode: opencodeEditor,
-};
+import { clearConfig } from './config.js';
+import { isGitRepo } from './project.js';
+import { removeProjectContext } from './context.js';
+import { runSync } from './sync-command.js';
+import { ok, info, warn, fail, resolveAuth, DEFAULT_HUB_URL, EDITORS } from './cli-helpers.js';
+import { runConnect } from './connect-command.js';
 const BANNER = [
     ' ██████╗ ██╗████████╗███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗',
     '██╔════╝ ██║╚══██╔══╝████╗  ██║██╔════╝╚██╗██╔╝██║   ██║██╔════╝',
@@ -37,10 +26,6 @@ const BANNER = [
     '╚██████╔╝██║   ██║   ██║ ╚████║███████╗██╔╝ ██╗╚██████╔╝███████║',
     ' ╚═════╝ ╚═╝   ╚═╝   ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝',
 ];
-const ok = (msg) => console.log(`  ${pc.green('✔')} ${msg}`);
-const info = (msg) => console.log(`  ${pc.cyan('ℹ')} ${msg}`);
-const warn = (msg) => console.log(`  ${pc.yellow('⚠')} ${msg}`);
-const fail = (msg) => console.error(`  ${pc.red('✗')} ${msg}`);
 function printBanner() {
     console.log('');
     for (const line of BANNER) {
@@ -50,44 +35,9 @@ function printBanner() {
     console.log(`   ${pc.dim('Plug into the living brain of your codebase')}`);
     console.log('');
 }
-/**
- * Resolve token + Hub URL from args/config. Exits on failure.
- */
-async function resolveAuth(tokenArg, hubOpt) {
-    const config = await loadConfig();
-    const token = tokenArg || config.hubToken;
-    const hubUrl = hubOpt || config.hubUrl || DEFAULT_HUB_URL;
-    if (!token) {
-        fail('No API token provided.');
-        console.error('');
-        console.error(`    Usage: ${pc.cyan('npx gitnexushub gnx_YOUR_TOKEN --editor cursor')}`);
-        console.error(`    Generate a token at: ${pc.cyan(hubUrl + '/settings/tokens')}`);
-        console.error('');
-        process.exit(1);
-    }
-    if (!token.startsWith('gnx_')) {
-        fail(`Invalid token format. Tokens must start with ${pc.bold('gnx_')}`);
-        console.error('');
-        process.exit(1);
-    }
-    const api = new HubAPI(hubUrl, token);
-    const user = await api.getMe().catch((err) => {
-        fail(`Authentication failed: ${err.message}`);
-        console.error(`    Check your token and try again.`);
-        console.error('');
-        process.exit(1);
-    });
-    ok(`Hello, ${pc.bold(user.name)}!`);
-    console.log('');
-    await saveConfig({ hubToken: token, hubUrl });
-    return { api, hubUrl, token };
-}
 // ─── CLI Setup ────────────────────────────────────────────────────
 const program = new Command();
-program
-    .name('gnx')
-    .description('Connect your editor to GitNexus Hub')
-    .version(PKG_VERSION);
+program.name('gnx').description('Connect your editor to GitNexus Hub').version(PKG_VERSION);
 // ─── connect command (also the default) ──────────────────────────
 const connectAction = async (tokenArg, opts) => {
     try {
@@ -145,120 +95,22 @@ program
         process.exit(1);
     }
 });
-program.parse();
-// ─── Connect Flow ─────────────────────────────────────────────────
-async function runConnect(tokenArg, opts) {
-    const { api, hubUrl, token } = await resolveAuth(tokenArg, opts.hub);
-    // ── Resolve editor ─────────────────────────────────────────────
-    const config = await loadConfig();
-    let editorId;
-    if (opts.editor) {
-        if (!(opts.editor in EDITORS)) {
-            fail(`Unknown editor: ${pc.bold(opts.editor)}`);
-            console.error(`    Supported: ${pc.cyan(Object.keys(EDITORS).join(', '))}`);
-            console.error('');
-            return process.exit(1);
-        }
-        editorId = opts.editor;
-    }
-    else if (!config.hubToken) {
-        const detected = await detectInstalledEditors();
-        if (detected.length === 1) {
-            editorId = detected[0];
-            info(`Auto-detected editor: ${pc.bold(EDITORS[editorId].name)}`);
-        }
-        else if (detected.length > 1) {
-            warn('Multiple editors detected. Please specify one:');
-            for (const id of detected) {
-                console.error(`      ${pc.cyan('--editor ' + id)}`);
-            }
-            console.error('');
-            return process.exit(1);
-        }
-        else {
-            fail('No editor detected. Please specify one:');
-            console.error(`      ${pc.cyan('--editor claude-code | cursor | windsurf | opencode')}`);
-            console.error('');
-            return process.exit(1);
-        }
-    }
-    // ── Configure editor MCP ────────────────────────────────────────
-    let skills = [];
-    if (editorId) {
-        const editor = EDITORS[editorId];
-        info(`Configuring ${pc.bold(editor.name)}...`);
-        const result = await editor.configure(hubUrl, token);
-        if (result.success) {
-            ok(result.message);
-            if (result.overrodeCli) {
-                console.log('');
-                console.log(`  ${pc.cyan('⬆')} ${pc.bold('GitNexus open-source detected — upgraded to Hub')}`);
-                console.log(`     ${pc.dim('Remote indexing. Deeper analysis. PR blast radius. Auto-reindex on push.')}`);
-                console.log(`     ${pc.dim('Your tools (query, context, impact) are unchanged — just faster and smarter.')}`);
-            }
-        }
-        else {
-            fail(result.message);
-        }
-        try {
-            const bundled = await generateConnectContext('_', {});
-            skills = bundled.skills;
-        }
-        catch {
-            // Skills load failed — continue without
-        }
-        if (editor.installSkills && skills.length > 0) {
-            const count = await editor.installSkills(skills);
-            if (count > 0) {
-                ok(`${count} skills installed`);
-            }
-        }
-    }
-    // ── Write project context ───────────────────────────────────────
-    if (!opts.skipProject && isGitRepo()) {
-        const remoteUrl = getGitRemoteUrl();
-        const remoteFullName = remoteUrl ? parseGitRemote(remoteUrl) : null;
-        if (remoteFullName) {
-            console.log('');
-            info(`Project: ${pc.bold(remoteFullName)}`);
-            try {
-                const repos = await api.listRepos();
-                const matched = matchRepo(remoteFullName, repos);
-                if (matched) {
-                    if (matched.status === 'ready') {
-                        const ctx = await generateConnectContext(matched.fullName, matched.stats || {});
-                        const result = await writeProjectContext(process.cwd(), ctx);
-                        for (const file of result.files) {
-                            ok(file);
-                        }
-                    }
-                    else {
-                        warn(`Repo status: ${pc.yellow(matched.status)} ${pc.dim('(waiting for indexing)')}`);
-                    }
-                }
-                else {
-                    warn('Repo not indexed on Hub yet');
-                    console.log(`      Add it at: ${pc.cyan(hubUrl)}`);
-                }
-            }
-            catch (err) {
-                fail(`Failed to fetch project context: ${err.message}`);
-            }
-        }
-        else {
-            console.log('');
-            warn('No GitHub remote found — skipping project context');
-        }
+// ─── sync command ─────────────────────────────────────────────────
+program
+    .command('sync')
+    .description('Push local working-tree state to the hub for re-indexing')
+    .option('--wait', 'Wait for indexing to complete', false)
+    .option('--hub <url>', 'Hub URL', DEFAULT_HUB_URL)
+    .action(async (opts) => {
+    try {
+        await runSync(opts);
     }
-    else if (!opts.skipProject) {
-        console.log('');
-        info('Not inside a git repo — skipping project context');
+    catch (err) {
+        console.error('  ' + pc.red('✗') + ' ' + (err.message || String(err)));
+        process.exit(1);
     }
-    // ── Summary ────────────────────────────────────────────────────
-    console.log('');
-    console.log(`  ${pc.green('✔')} ${pc.bold('Done!')} Open your editor — GitNexus MCP is ready.`);
-    console.log('');
-}
+});
+program.parse();
 // ─── Disconnect Flow ──────────────────────────────────────────────
 async function runDisconnect(opts) {
     // ── Resolve which editors to clean ─────────────────────────────
@@ -332,7 +184,7 @@ async function runIndex(repo, opts) {
         // Already added — look it up instead of failing
         if (msg.includes('already added')) {
             const repos = await api.listRepos();
-            const existing = repos.find(r => r.fullName === fullName);
+            const existing = repos.find((r) => r.fullName === fullName);
             if (existing) {
                 if (existing.status === 'ready') {
                     ok(`${pc.bold(fullName)} is already indexed and ready.`);
@@ -367,7 +219,7 @@ async function runIndex(repo, opts) {
     const spinFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
     let frame = 0;
     while (true) {
-        await new Promise(r => setTimeout(r, 2000));
+        await new Promise((r) => setTimeout(r, 2000));
         try {
             const detail = await api.getRepo(repoId);
             const spinner = pc.cyan(spinFrames[frame % spinFrames.length]);

package/dist/registry.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Local repo registry — stored at ~/.gitnexus/connect-registry.json.
+ *
+ * Maps local filesystem paths to hub repo identities so that `gnx sync`
+ * and the editor hook script can resolve cwd → hub_repo_id without
+ * talking to the hub. The registry is written by `gnx sync` when a repo
+ * is first registered and read on every subsequent sync and every hook
+ * invocation.
+ *
+ * Matcher semantics (ported from gitnexus/src/core/augmentation/engine.ts
+ * but intentionally kept separate — the OSS registry has a different
+ * shape keyed by storagePath/lbugPath):
+ *   - longest-path match wins (inner repo beats outer)
+ *   - symlinks in cwd are resolved via fs.realpath before matching
+ *   - match must land on a path-separator boundary so /projects/foo does
+ *     not match /projects/foobar
+ *   - falls back to path.resolve on realpath errors so non-existent
+ *     paths still return a best-effort syntactic match
+ */
+export interface RegistryEntry {
+    localPath: string;
+    fullName: string;
+    hubRepoId: string;
+    lastSyncedSha?: string;
+    lastSyncedAt?: string;
+}
+export declare function readRegistry(): Promise<RegistryEntry[]>;
+export declare function writeRegistry(entries: RegistryEntry[]): Promise<void>;
+export declare function upsertRegistryEntry(entry: RegistryEntry): Promise<void>;
+/**
+ * Resolve a working directory to its best-matching registry entry.
+ *
+ * Uses longest-path matching with symlink resolution and path-boundary
+ * checks so /projects/foo does not match /projects/foobar. When `opts.entries`
+ * is passed, resolution is done against that in-memory list (used by tests
+ * and by callers that already hold the entries); otherwise the registry is
+ * read from disk.
+ */
+export declare function resolveCwdToRepo(cwd: string, opts?: {
+    entries?: RegistryEntry[];
+}): Promise<RegistryEntry | null>;

package/dist/registry.js

@@ -0,0 +1,92 @@
+/**
+ * Local repo registry — stored at ~/.gitnexus/connect-registry.json.
+ *
+ * Maps local filesystem paths to hub repo identities so that `gnx sync`
+ * and the editor hook script can resolve cwd → hub_repo_id without
+ * talking to the hub. The registry is written by `gnx sync` when a repo
+ * is first registered and read on every subsequent sync and every hook
+ * invocation.
+ *
+ * Matcher semantics (ported from gitnexus/src/core/augmentation/engine.ts
+ * but intentionally kept separate — the OSS registry has a different
+ * shape keyed by storagePath/lbugPath):
+ *   - longest-path match wins (inner repo beats outer)
+ *   - symlinks in cwd are resolved via fs.realpath before matching
+ *   - match must land on a path-separator boundary so /projects/foo does
+ *     not match /projects/foobar
+ *   - falls back to path.resolve on realpath errors so non-existent
+ *     paths still return a best-effort syntactic match
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+function getRegistryPath() {
+    return path.join(os.homedir(), '.gitnexus', 'connect-registry.json');
+}
+export async function readRegistry() {
+    try {
+        const raw = await fs.readFile(getRegistryPath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.entries) ? parsed.entries : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function writeRegistry(entries) {
+    const p = getRegistryPath();
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, JSON.stringify({ entries }, null, 2));
+}
+export async function upsertRegistryEntry(entry) {
+    const entries = await readRegistry();
+    const idx = entries.findIndex((e) => e.hubRepoId === entry.hubRepoId);
+    if (idx >= 0)
+        entries[idx] = { ...entries[idx], ...entry };
+    else
+        entries.push(entry);
+    await writeRegistry(entries);
+}
+/**
+ * Resolve a working directory to its best-matching registry entry.
+ *
+ * Uses longest-path matching with symlink resolution and path-boundary
+ * checks so /projects/foo does not match /projects/foobar. When `opts.entries`
+ * is passed, resolution is done against that in-memory list (used by tests
+ * and by callers that already hold the entries); otherwise the registry is
+ * read from disk.
+ */
+export async function resolveCwdToRepo(cwd, opts) {
+    const entries = opts?.entries ?? (await readRegistry());
+    if (entries.length === 0)
+        return null;
+    let resolved;
+    try {
+        resolved = await fs.realpath(path.resolve(cwd));
+    }
+    catch {
+        resolved = path.resolve(cwd);
+    }
+    // Normalize casing on Windows so D:\foo and d:\foo match.
+    const isWindows = process.platform === 'win32';
+    const normalizedCwd = isWindows ? resolved.toLowerCase() : resolved;
+    const sep = path.sep;
+    let best = null;
+    let bestLen = 0;
+    for (const entry of entries) {
+        let entryPath;
+        try {
+            entryPath = await fs.realpath(path.resolve(entry.localPath));
+        }
+        catch {
+            entryPath = path.resolve(entry.localPath);
+        }
+        const normalizedEntry = isWindows ? entryPath.toLowerCase() : entryPath;
+        const matched = normalizedCwd === normalizedEntry || normalizedCwd.startsWith(normalizedEntry + sep);
+        if (matched && normalizedEntry.length > bestLen) {
+            best = entry;
+            bestLen = normalizedEntry.length;
+        }
+    }
+    return best;
+}

package/dist/sync-command.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `gnx sync` — push local working-tree state to the hub for re-indexing.
+ *
+ * Flow:
+ *   1. Resolve cwd → registered repo (from connect-registry.json)
+ *   2. If not registered, look up via hub API by GitHub remote, save to registry
+ *   3. If still not found, tell user to add via hub UI
+ *   4. Compute local HEAD and dirty state
+ *   5. Short-circuit if hub already has this commit AND tree is clean
+ *   6. Build tarball, upload, optionally poll for completion
+ */
+export interface SyncOptions {
+    wait?: boolean;
+    hub?: string;
+}
+export declare function runSync(opts: SyncOptions): Promise<void>;