@wenrwa/marketplace-cli 0.4.3 → 0.4.4

package/dist/__tests__/bridge-repo-checkout.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bridge-repo-checkout.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const repoCheckout_1 = require("../bridge/repoCheckout");
+const BASE = '/Users/t/wenrwa-workspaces';
+const makeDeps = (existing = [], cloneFails = false) => {
+    const runs = [];
+    return {
+        runs,
+        deps: {
+            baseDir: BASE,
+            exists: (p) => existing.includes(p),
+            mkdir: (_p) => { },
+            run: async (cmd, args) => {
+                runs.push([cmd, ...args]);
+                if (cloneFails)
+                    throw new Error('clone failed');
+                return { stdout: '', code: 0 };
+            },
+        },
+    };
+};
+describe('parseRepoFullName', () => {
+    it('handles https, trailing .git, and bare owner/repo', () => {
+        expect((0, repoCheckout_1.parseRepoFullName)('https://github.com/BunnyDAO/CBP')).toBe('BunnyDAO/CBP');
+        expect((0, repoCheckout_1.parseRepoFullName)('https://github.com/BunnyDAO/CBP.git')).toBe('BunnyDAO/CBP');
+        expect((0, repoCheckout_1.parseRepoFullName)('BunnyDAO/CBP')).toBe('BunnyDAO/CBP');
+        expect((0, repoCheckout_1.parseRepoFullName)('not a repo url')).toBeNull();
+    });
+});
+describe('ensureRepoCheckout', () => {
+    it('reuses an existing checkout without running git', async () => {
+        const { deps, runs } = makeDeps([`${BASE}/BunnyDAO/CBP`]);
+        const result = await (0, repoCheckout_1.ensureRepoCheckout)('https://github.com/BunnyDAO/CBP', deps);
+        expect(result).toEqual({ path: `${BASE}/BunnyDAO/CBP`, action: 'existing' });
+        expect(runs).toHaveLength(0);
+    });
+    it('clones a missing repo into the workspace base dir', async () => {
+        const { deps, runs } = makeDeps();
+        const result = await (0, repoCheckout_1.ensureRepoCheckout)('https://github.com/BunnyDAO/CBP.git', deps);
+        expect(result).toEqual({ path: `${BASE}/BunnyDAO/CBP`, action: 'cloned' });
+        expect(runs[0].join(' ')).toBe(`git clone https://github.com/BunnyDAO/CBP.git ${BASE}/BunnyDAO/CBP`);
+    });
+    it('reports failure without throwing when the clone fails (no local git auth, etc.)', async () => {
+        const { deps } = makeDeps([], true);
+        const result = await (0, repoCheckout_1.ensureRepoCheckout)('https://github.com/Private/Repo', deps);
+        expect(result.action).toBe('failed');
+    });
+    it('rejects unparseable repo urls', async () => {
+        const { deps } = makeDeps();
+        const result = await (0, repoCheckout_1.ensureRepoCheckout)('garbage', deps);
+        expect(result.action).toBe('failed');
+    });
+});

package/dist/__tests__/bridge-server.test.js

@@ -140,6 +140,27 @@ describe('bridge WebSocket server', () => {
         });
         expect(bad.status).toBe(403);
     });
+    it('threads repoUrl through resolveCwd into the PTY spawn and the opened frame', async () => {
+        await handle.close();
+        const cwds = [];
+        const factory = { spawn: (o) => { cwds.push(o.cwd); const p = new FakePty(); ptys.push(p); return p; } };
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            resolveCwd: async (repoUrl) => (repoUrl.includes('CBP') ? '/tmp/wenrwa-workspaces/BunnyDAO/CBP' : null),
+        });
+        const { ws, q } = await openAndAuth(handle.port);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, repoUrl: 'https://github.com/BunnyDAO/CBP' }));
+        const opened = await q.next();
+        expect(opened.cwd).toBe('/tmp/wenrwa-workspaces/BunnyDAO/CBP');
+        expect(cwds[0]).toBe('/tmp/wenrwa-workspaces/BunnyDAO/CBP');
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, repoUrl: 'https://github.com/Other/Repo' }));
+        const fallback = await q.next();
+        expect(fallback.cwd).toBeUndefined();
+        expect(fallback.note).toContain('home directory');
+        ws.close();
+    });
     it('unauthenticated frames are rejected', async () => {
         const ws = connect(handle.port);
         await new Promise((r) => ws.on('open', r));

package/dist/bridge/realPty.js

@@ -68,12 +68,12 @@ function realPtyFactory() {
     const pty = require('node-pty');
     const shell = process.env.SHELL || (os.platform() === 'win32' ? 'powershell.exe' : '/bin/bash');
     return {
-        spawn: ({ cols, rows }) => {
+        spawn: ({ cols, rows, cwd }) => {
             const proc = pty.spawn(shell, [], {
                 name: 'xterm-256color',
                 cols,
                 rows,
-                cwd: os.homedir(),
+                cwd: cwd || os.homedir(),
                 env: process.env,
             });
             return {

package/dist/bridge/repoCheckout.d.ts

@@ -0,0 +1,24 @@
+/**
+ * bct UX round 2 (2026-07-30) — workspace-scoped terminals.
+ *
+ * The arena's mental model is workspace = repo, so the Terminal pane sends
+ * the workspace's GitHub URL with `open`, and the bridge lands the shell in
+ * a local checkout of that repo (cloning on first use with the USER'S own
+ * git credentials — the platform never touches repo auth). Checkouts live
+ * under ~/wenrwa-workspaces/<owner>/<repo>.
+ */
+export interface RepoCheckoutDeps {
+    baseDir: string;
+    exists: (path: string) => boolean;
+    mkdir: (path: string) => void;
+    run: (cmd: string, args: string[]) => Promise<{
+        stdout: string;
+        code: number;
+    }>;
+}
+export interface CheckoutResult {
+    path?: string;
+    action: 'existing' | 'cloned' | 'failed';
+}
+export declare function parseRepoFullName(repoUrl: string): string | null;
+export declare function ensureRepoCheckout(repoUrl: string, deps: RepoCheckoutDeps): Promise<CheckoutResult>;

package/dist/bridge/repoCheckout.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * bct UX round 2 (2026-07-30) — workspace-scoped terminals.
+ *
+ * The arena's mental model is workspace = repo, so the Terminal pane sends
+ * the workspace's GitHub URL with `open`, and the bridge lands the shell in
+ * a local checkout of that repo (cloning on first use with the USER'S own
+ * git credentials — the platform never touches repo auth). Checkouts live
+ * under ~/wenrwa-workspaces/<owner>/<repo>.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRepoFullName = parseRepoFullName;
+exports.ensureRepoCheckout = ensureRepoCheckout;
+function parseRepoFullName(repoUrl) {
+    const m = repoUrl.match(/github\.com[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?(?:[/?#].*)?$/) ||
+        repoUrl.match(/^([\w.-]+)\/([\w.-]+)$/);
+    return m ? `${m[1]}/${m[2]}` : null;
+}
+async function ensureRepoCheckout(repoUrl, deps) {
+    const fullName = parseRepoFullName(repoUrl);
+    if (!fullName)
+        return { action: 'failed' };
+    const path = `${deps.baseDir}/${fullName}`;
+    if (deps.exists(path))
+        return { path, action: 'existing' };
+    try {
+        deps.mkdir(path.slice(0, path.lastIndexOf('/')));
+        await deps.run('git', ['clone', repoUrl, path]);
+        return { path, action: 'cloned' };
+    }
+    catch {
+        return { action: 'failed' };
+    }
+}

package/dist/bridge/server.d.ts

@@ -5,6 +5,9 @@ export interface BridgeServerOpts {
     sessions: SessionManager;
     /** 0 (default) = ephemeral port. */
     port?: number;
+    /** Workspace-scoped terminals: resolve a repo URL to a local checkout dir
+     *  (cloned on first use). Absent/null result → shell opens in $HOME. */
+    resolveCwd?: (repoUrl: string) => Promise<string | null>;
 }
 export interface BridgeServerHandle {
     port: number;

package/dist/bridge/server.js

@@ -137,9 +137,19 @@ function startBridgeServer(opts) {
             try {
                 switch (frame.t) {
                     case 'open': {
-                        const sessionId = opts.sessions.open({ cols: frame.cols, rows: frame.rows });
-                        attachTo(sessionId);
-                        send(ws, { t: 'opened', sessionId });
+                        const openSession = (cwd, note) => {
+                            const sessionId = opts.sessions.open({ cols: frame.cols, rows: frame.rows, cwd });
+                            attachTo(sessionId);
+                            send(ws, { t: 'opened', sessionId, ...(cwd ? { cwd } : {}), ...(note ? { note } : {}) });
+                        };
+                        if (frame.repoUrl && opts.resolveCwd) {
+                            opts.resolveCwd(frame.repoUrl)
+                                .then((cwd) => openSession(cwd ?? undefined, cwd ? undefined : 'repo checkout unavailable — opened in home directory'))
+                                .catch(() => openSession(undefined, 'repo checkout failed — opened in home directory'));
+                        }
+                        else {
+                            openSession();
+                        }
                         break;
                     }
                     case 'attach': {

package/dist/bridge/sessionManager.d.ts

@@ -9,6 +9,7 @@ export interface PtyFactory {
     spawn(opts: {
         cols: number;
         rows: number;
+        cwd?: string;
     }): PtyLike;
 }
 export type SinkFrame = {
@@ -35,6 +36,7 @@ export declare class SessionManager {
     open(opts: {
         cols: number;
         rows: number;
+        cwd?: string;
     }): string;
     attach(sessionId: string, sink: Sink): AttachmentHandle;
     close(sessionId: string): void;

package/dist/commands/bridge.js

@@ -57,6 +57,7 @@ const realPty_1 = require("../bridge/realPty");
 const config_1 = require("../bridge/config");
 const mcpRegister_1 = require("../bridge/mcpRegister");
 const autostart_1 = require("../bridge/autostart");
+const repoCheckout_1 = require("../bridge/repoCheckout");
 const config_2 = require("../utils/config");
 exports.DEFAULT_BRIDGE_PORT = 8377;
 const DEFAULT_ORIGIN = 'https://app.hiveop.io';
@@ -120,11 +121,25 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         console.log(chalk_1.default.yellow('! claude binary not found — bridge will run, but install Claude Code for MCP world-wiring'));
     // 3. Serve.
     const sessionToken = crypto.randomBytes(16).toString('hex');
+    const workspacesBase = `${os.homedir()}/wenrwa-workspaces`;
     const handle = await (0, server_1.startBridgeServer)({
         sessionToken,
         allowedOrigin: opts.origin,
         sessions: new sessionManager_1.SessionManager((0, realPty_1.realPtyFactory)()),
         port: Number(opts.port),
+        // Workspace-scoped shells: the pane sends the workspace's GitHub URL;
+        // we land the PTY in a local checkout (user's own git credentials).
+        resolveCwd: async (repoUrl) => {
+            const result = await (0, repoCheckout_1.ensureRepoCheckout)(repoUrl, {
+                baseDir: workspacesBase,
+                exists: (p) => fs.existsSync(p),
+                mkdir: (p) => fs.mkdirSync(p, { recursive: true }),
+                run: execRunner,
+            });
+            if (result.action === 'cloned')
+                console.log(chalk_1.default.green(`✓ Cloned ${repoUrl} → ${result.path}`));
+            return result.path ?? null;
+        },
     });
     (0, config_1.writeDiscoveryFile)({ port: handle.port, sessionToken });
     fs.appendFileSync((0, config_1.bridgeLogPath)(), `${new Date().toISOString()} bridge up on ${handle.address}:${handle.port}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenrwa/marketplace-cli",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "CLI tool for the Wenrwa Agent Marketplace — monitor bounties, agents, workspaces, and treasury from your terminal",
   "author": "Wenrwa <dev@wenrwa.com>",
   "license": "MIT",