@lakakala/kgit 0.3.2 → 0.4.0

package/dist/commands/append.js

@@ -1,26 +1,27 @@
 import path from 'node:path';
-import fs from 'node:fs';
 import { loadConfig, findProject } from '../config.js';
+import { createRunner } from '../runner.js';
 import { addWorktree, isGitRepo } from '../git.js';
 export async function appendCommand(workspaceName, projectEntries, newBranch) {
     const config = loadConfig();
+    const r = createRunner(config.machine);
     const targetDir = path.join(config.workspace, workspaceName);
     const branchName = newBranch ?? workspaceName;
-    if (!fs.existsSync(targetDir)) {
+    if (!(await r.exists(targetDir))) {
         throw new Error(`Workspace directory does not exist: ${targetDir}. Use "kgit new" to create it first.`);
     }
     for (const entry of projectEntries) {
         const project = findProject(config, entry.name);
-        if (!(await isGitRepo(project.path))) {
+        if (!(await isGitRepo(r, project.path))) {
             throw new Error(`Not a git repository: ${project.path}`);
         }
         const worktreePath = path.join(targetDir, project.name);
-        if (fs.existsSync(worktreePath)) {
+        if (await r.exists(worktreePath)) {
             console.warn(`Worktree already exists, skipping: ${worktreePath}`);
             continue;
         }
         console.log(`Adding worktree for "${project.name}" (new branch: ${branchName}, base: ${entry.branch}) -> ${worktreePath}`);
-        await addWorktree(project.path, worktreePath, branchName, entry.branch);
+        await addWorktree(r, project.path, worktreePath, branchName, entry.branch);
     }
     console.log(`\nProjects appended to workspace "${workspaceName}" at ${targetDir}`);
 }

package/dist/commands/edit.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
-import fs from 'node:fs';
 import { execa } from 'execa';
 import { loadConfig } from '../config.js';
+import { createRunner } from '../runner.js';
 const IDE_COMMANDS = {
     code: 'code',
     trae: 'trae',
@@ -14,6 +14,8 @@ const IDE_COMMANDS = {
     webstorm: 'webstorm',
 };
 const TERMINAL_IDES = new Set(['nvim', 'vim', 'vi', 'nano']);
+// IDEs that support --remote ssh-remote+host
+const SSH_REMOTE_IDES = new Set(['code', 'cursor']);
 async function detectDefaultIde() {
     for (const cmd of ['code', 'trae', 'cursor', 'nvim', 'vim']) {
         try {
@@ -26,10 +28,14 @@ async function detectDefaultIde() {
     }
     return null;
 }
+function parseSshHost(machine) {
+    return machine.replace(/^ssh:\/\//, '');
+}
 export async function editCommand(workspaceName, projectName, options) {
     const config = loadConfig();
+    const r = createRunner(config.machine);
     const worktreePath = path.join(config.workspace, workspaceName, projectName);
-    if (!fs.existsSync(worktreePath)) {
+    if (!(await r.exists(worktreePath))) {
         throw new Error(`Project path does not exist: ${worktreePath}`);
     }
     let ideName = options.ide?.toLowerCase()
@@ -43,11 +49,30 @@ export async function editCommand(workspaceName, projectName, options) {
         console.log(`Using detected IDE: ${ideName}`);
     }
     const command = IDE_COMMANDS[ideName] ?? ideName;
-    console.log(`Opening ${worktreePath} with ${command}...`);
-    if (TERMINAL_IDES.has(ideName)) {
-        await execa(command, [worktreePath], { stdio: 'inherit' });
+    if (config.machine) {
+        const host = parseSshHost(config.machine);
+        if (SSH_REMOTE_IDES.has(ideName)) {
+            // VS Code / Cursor: use --remote ssh-remote+host
+            console.log(`Opening ${worktreePath} on ${host} with ${command} --remote...`);
+            execa(command, ['--remote', `ssh-remote+${host}`, worktreePath], { detached: true, stdio: 'ignore' }).unref();
+        }
+        else if (TERMINAL_IDES.has(ideName)) {
+            // Terminal editors: ssh -t host 'vim /path'
+            console.log(`Opening ${worktreePath} on ${host} with ${command}...`);
+            await execa('ssh', ['-t', host, command, worktreePath], { stdio: 'inherit' });
+        }
+        else {
+            console.error(`Error: "${ideName}" does not support remote editing. Use code, cursor, or a terminal editor (vim, nvim).`);
+            process.exit(1);
+        }
     }
     else {
-        execa(command, [worktreePath], { detached: true, stdio: 'ignore' }).unref();
+        console.log(`Opening ${worktreePath} with ${command}...`);
+        if (TERMINAL_IDES.has(ideName)) {
+            await execa(command, [worktreePath], { stdio: 'inherit' });
+        }
+        else {
+            execa(command, [worktreePath], { detached: true, stdio: 'ignore' }).unref();
+        }
     }
 }

package/dist/commands/list.js

@@ -1,36 +1,39 @@
 import path from 'node:path';
-import fs from 'node:fs';
 import { loadConfig } from '../config.js';
-import { execa } from 'execa';
-async function getCurrentBranch(worktreePath) {
-    try {
-        const { stdout } = await execa('git', ['-C', worktreePath, 'branch', '--show-current'], { stdio: 'pipe' });
-        return stdout.trim() || 'detached HEAD';
-    }
-    catch {
-        return 'unknown';
-    }
-}
+import { createRunner } from '../runner.js';
 export async function listCommand() {
     const config = loadConfig();
-    if (!fs.existsSync(config.workspace)) {
+    const r = createRunner(config.machine);
+    if (!(await r.exists(config.workspace))) {
         console.log('No workspaces found (workspace directory does not exist).');
         return;
     }
-    const entries = fs.readdirSync(config.workspace, { withFileTypes: true });
-    const workspaces = entries.filter(e => e.isDirectory());
+    const entries = await r.readdir(config.workspace);
+    const workspaces = [];
+    for (const entry of entries) {
+        if (await r.isDirectory(path.join(config.workspace, entry))) {
+            workspaces.push(entry);
+        }
+    }
     if (workspaces.length === 0) {
         console.log('No workspaces found.');
         return;
     }
     for (const ws of workspaces) {
-        console.log(`${ws.name}`);
-        const wsPath = path.join(config.workspace, ws.name);
-        const projects = fs.readdirSync(wsPath, { withFileTypes: true }).filter(e => e.isDirectory());
-        for (const proj of projects) {
-            const projPath = path.join(wsPath, proj.name);
-            const branch = await getCurrentBranch(projPath);
-            console.log(`  └─ ${proj.name}  (${branch})`);
+        console.log(`${ws}`);
+        const wsPath = path.join(config.workspace, ws);
+        const children = await r.readdir(wsPath);
+        for (const proj of children) {
+            const projPath = path.join(wsPath, proj);
+            if (!(await r.isDirectory(projPath)))
+                continue;
+            let branch = 'unknown';
+            try {
+                const { stdout } = await r.exec(['git', '-C', projPath, 'branch', '--show-current']);
+                branch = stdout.trim() || 'detached HEAD';
+            }
+            catch { /* ignore */ }
+            console.log(`  └─ ${proj}  (${branch})`);
         }
     }
 }

package/dist/commands/new.js

@@ -1,24 +1,25 @@
 import path from 'node:path';
-import fs from 'node:fs';
 import { loadConfig, findProject } from '../config.js';
+import { createRunner } from '../runner.js';
 import { addWorktree, isGitRepo } from '../git.js';
 export async function newCommand(workspaceName, projectEntries, newBranch) {
     const config = loadConfig();
+    const r = createRunner(config.machine);
     const targetDir = path.join(config.workspace, workspaceName);
     const branchName = newBranch ?? workspaceName;
-    if (fs.existsSync(targetDir)) {
+    if (await r.exists(targetDir)) {
         throw new Error(`Workspace directory already exists: ${targetDir}`);
     }
-    await fs.promises.mkdir(targetDir, { recursive: true });
+    await r.mkdir(targetDir);
     console.log(`Created workspace directory: ${targetDir}`);
     for (const entry of projectEntries) {
         const project = findProject(config, entry.name);
-        if (!(await isGitRepo(project.path))) {
+        if (!(await isGitRepo(r, project.path))) {
             throw new Error(`Not a git repository: ${project.path}`);
         }
         const worktreePath = path.join(targetDir, project.name);
         console.log(`Adding worktree for "${project.name}" (new branch: ${branchName}, base: ${entry.branch}) -> ${worktreePath}`);
-        await addWorktree(project.path, worktreePath, branchName, entry.branch);
+        await addWorktree(r, project.path, worktreePath, branchName, entry.branch);
     }
     console.log(`\nWorkspace "${workspaceName}" created successfully at ${targetDir}`);
 }

package/dist/commands/remove.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
-import fs from 'node:fs';
 import readline from 'node:readline';
 import { loadConfig, findProject } from '../config.js';
+import { createRunner } from '../runner.js';
 import { removeWorktree, isBranchSyncedToRemote } from '../git.js';
 function confirm(question) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -12,8 +12,8 @@ function confirm(question) {
         });
     });
 }
-async function checkAndRemove(repoPath, worktreePath, projectName) {
-    const synced = await isBranchSyncedToRemote(worktreePath);
+async function checkAndRemove(r, repoPath, worktreePath, projectName) {
+    const synced = await isBranchSyncedToRemote(r, worktreePath);
     if (!synced) {
         console.warn(`  Warning: "${projectName}" has unpushed commits or no remote tracking branch.`);
         const ok = await confirm(`  Remove worktree "${projectName}" anyway?`);
@@ -23,25 +23,26 @@ async function checkAndRemove(repoPath, worktreePath, projectName) {
         }
     }
     console.log(`Removing worktree "${projectName}" from ${repoPath}`);
-    await removeWorktree(repoPath, worktreePath);
+    await removeWorktree(r, repoPath, worktreePath);
 }
 export async function removeCommand(workspaceName, projectEntries) {
     const config = loadConfig();
+    const r = createRunner(config.machine);
     const targetDir = path.join(config.workspace, workspaceName);
-    if (!fs.existsSync(targetDir)) {
+    if (!(await r.exists(targetDir))) {
         throw new Error(`Workspace directory does not exist: ${targetDir}`);
     }
     if (projectEntries.length === 0) {
-        const entries = fs.readdirSync(targetDir);
+        const entries = await r.readdir(targetDir);
         for (const entry of entries) {
             const worktreePath = path.join(targetDir, entry);
             const project = config.projects.find(p => p.name === entry);
-            if (project && fs.statSync(worktreePath).isDirectory()) {
-                await checkAndRemove(project.path, worktreePath, entry);
+            if (project && await r.isDirectory(worktreePath)) {
+                await checkAndRemove(r, project.path, worktreePath, entry);
             }
         }
-        if (fs.readdirSync(targetDir).length === 0) {
-            fs.rmSync(targetDir, { recursive: true, force: true });
+        if ((await r.readdir(targetDir)).length === 0) {
+            await r.rm(targetDir);
             console.log(`Workspace "${workspaceName}" removed.`);
         }
         else {
@@ -52,14 +53,14 @@ export async function removeCommand(workspaceName, projectEntries) {
         for (const entry of projectEntries) {
             const project = findProject(config, entry.name);
             const worktreePath = path.join(targetDir, project.name);
-            if (!fs.existsSync(worktreePath)) {
+            if (!(await r.exists(worktreePath))) {
                 console.warn(`Worktree not found, skipping: ${worktreePath}`);
                 continue;
             }
-            await checkAndRemove(project.path, worktreePath, project.name);
+            await checkAndRemove(r, project.path, worktreePath, project.name);
         }
-        if (fs.readdirSync(targetDir).length === 0) {
-            fs.rmdirSync(targetDir);
+        if ((await r.readdir(targetDir)).length === 0) {
+            await r.rmdir(targetDir);
             console.log(`Workspace directory is now empty and has been removed.`);
         }
     }

package/dist/config.d.ts

@@ -22,6 +22,7 @@ declare const ConfigSchema: z.ZodObject<{
         path: string;
     }>, "many">;
     ide: z.ZodOptional<z.ZodString>;
+    machine: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     workspace: string;
     projects: {
@@ -29,6 +30,7 @@ declare const ConfigSchema: z.ZodObject<{
         path: string;
     }[];
     ide?: string | undefined;
+    machine?: string | undefined;
 }, {
     workspace: string;
     projects: {
@@ -36,6 +38,7 @@ declare const ConfigSchema: z.ZodObject<{
         path: string;
     }[];
     ide?: string | undefined;
+    machine?: string | undefined;
 }>;
 export type Project = z.infer<typeof ProjectSchema>;
 export type Config = z.infer<typeof ConfigSchema>;

package/dist/config.js

@@ -11,6 +11,7 @@ const ConfigSchema = z.object({
     workspace: z.string(),
     projects: z.array(ProjectSchema),
     ide: z.string().optional(),
+    machine: z.string().optional(),
 });
 function expandEnvVars(value) {
     return value.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_, name) => {
@@ -26,6 +27,8 @@ function expandConfig(config) {
             name: p.name,
             path: expandEnvVars(p.path),
         })),
+        ide: config.ide,
+        machine: config.machine,
     };
 }
 export function loadConfig() {

package/dist/git.d.ts

@@ -1,4 +1,5 @@
-export declare function addWorktree(repoPath: string, worktreePath: string, newBranch: string, baseBranch: string): Promise<void>;
-export declare function isBranchSyncedToRemote(worktreePath: string): Promise<boolean>;
-export declare function removeWorktree(repoPath: string, worktreePath: string): Promise<void>;
-export declare function isGitRepo(dirPath: string): Promise<boolean>;
+import type { Runner } from './runner.js';
+export declare function addWorktree(r: Runner, repoPath: string, worktreePath: string, newBranch: string, baseBranch: string): Promise<void>;
+export declare function isBranchSyncedToRemote(r: Runner, worktreePath: string): Promise<boolean>;
+export declare function removeWorktree(r: Runner, repoPath: string, worktreePath: string): Promise<void>;
+export declare function isGitRepo(r: Runner, dirPath: string): Promise<boolean>;

package/dist/git.js

@@ -1,23 +1,11 @@
-import { execa } from 'execa';
-import fs from 'node:fs';
 import path from 'node:path';
-async function run(args) {
-    console.log(`  $ ${args.join(' ')}`);
-    const result = await execa(args[0], args.slice(1), { all: true }).catch(err => {
-        if (err.all)
-            process.stderr.write(err.all + '\n');
-        throw err;
-    });
-    if (result.all)
-        process.stdout.write(result.all + '\n');
-}
-async function localBranchExists(repoPath, branch) {
-    const { stdout } = await execa('git', ['-C', repoPath, 'branch', '--list', branch], { stdio: 'pipe' });
+async function localBranchExists(r, repoPath, branch) {
+    const { stdout } = await r.exec(['git', '-C', repoPath, 'branch', '--list', branch]);
     return stdout.trim().length > 0;
 }
-async function remoteBranchExists(repoPath, branch) {
+async function remoteBranchExists(r, repoPath, branch) {
     try {
-        const { stdout } = await execa('git', ['-C', repoPath, 'ls-remote', '--heads', 'origin', branch], { stdio: 'pipe' });
+        const { stdout } = await r.exec(['git', '-C', repoPath, 'ls-remote', '--heads', 'origin', branch]);
         if (stdout.trim().length === 0)
             return null;
         return `origin/${branch}`;
@@ -26,37 +14,57 @@ async function remoteBranchExists(repoPath, branch) {
         return null;
     }
 }
-export async function addWorktree(repoPath, worktreePath, newBranch, baseBranch) {
-    await fs.promises.mkdir(path.dirname(worktreePath), { recursive: true });
-    if (await localBranchExists(repoPath, newBranch)) {
-        console.log(`  Branch "${newBranch}" exists locally, using it directly.`);
-        await run(['git', '-C', repoPath, 'worktree', 'add', worktreePath, newBranch]);
+async function syncLocalBranch(r, repoPath, branch) {
+    await r.run(['git', '-C', repoPath, 'fetch', 'origin', branch]);
+    const { stdout: remoteRef } = await r.exec(['git', '-C', repoPath, 'rev-parse', '--verify', `origin/${branch}`]).catch(() => ({ stdout: '' }));
+    if (!remoteRef.trim()) {
+        console.log(`  No remote tracking branch for "${branch}", skipping sync.`);
+        return;
+    }
+    const { stdout: headRef } = await r.exec(['git', '-C', repoPath, 'symbolic-ref', 'HEAD']).catch(() => ({ stdout: '' }));
+    if (headRef.trim() === `refs/heads/${branch}`) {
+        console.log(`  Branch "${branch}" is currently checked out, skipping sync.`);
+        return;
+    }
+    const { stdout: aheadCount } = await r.exec(['git', '-C', repoPath, 'rev-list', '--count', `origin/${branch}..${branch}`]);
+    if (parseInt(aheadCount.trim(), 10) > 0) {
+        console.warn(`  Warning: "${branch}" has local commits not in remote, skipping sync.`);
+        return;
+    }
+    await r.run(['git', '-C', repoPath, 'branch', '-f', branch, `origin/${branch}`]);
+}
+export async function addWorktree(r, repoPath, worktreePath, newBranch, baseBranch) {
+    await r.mkdir(path.dirname(worktreePath));
+    if (await localBranchExists(r, repoPath, newBranch)) {
+        console.log(`  Branch "${newBranch}" exists locally, syncing with remote...`);
+        await syncLocalBranch(r, repoPath, newBranch);
+        await r.run(['git', '-C', repoPath, 'worktree', 'add', worktreePath, newBranch]);
         return;
     }
-    const remoteBranch = await remoteBranchExists(repoPath, newBranch);
+    const remoteBranch = await remoteBranchExists(r, repoPath, newBranch);
     if (remoteBranch) {
         console.log(`  Branch "${newBranch}" found on remote (${remoteBranch}), creating tracking branch.`);
-        await run(['git', '-C', repoPath, 'worktree', 'add', '--track', '-b', newBranch, worktreePath, remoteBranch]);
+        await r.run(['git', '-C', repoPath, 'worktree', 'add', '--track', '-b', newBranch, worktreePath, remoteBranch]);
         return;
     }
-    await run(['git', '-C', repoPath, 'worktree', 'add', '-b', newBranch, worktreePath, baseBranch]);
+    await r.run(['git', '-C', repoPath, 'worktree', 'add', '-b', newBranch, worktreePath, baseBranch]);
 }
-export async function isBranchSyncedToRemote(worktreePath) {
+export async function isBranchSyncedToRemote(r, worktreePath) {
     try {
-        await execa('git', ['-C', worktreePath, 'rev-parse', '--abbrev-ref', '@{u}'], { stdio: 'pipe' });
+        await r.exec(['git', '-C', worktreePath, 'rev-parse', '--abbrev-ref', '@{u}']);
     }
     catch {
         return false;
     }
-    const { stdout } = await execa('git', ['-C', worktreePath, 'rev-list', '--count', '@{u}..HEAD'], { stdio: 'pipe' });
+    const { stdout } = await r.exec(['git', '-C', worktreePath, 'rev-list', '--count', '@{u}..HEAD']);
     return parseInt(stdout.trim(), 10) === 0;
 }
-export async function removeWorktree(repoPath, worktreePath) {
-    await run(['git', '-C', repoPath, 'worktree', 'remove', worktreePath, '--force']);
+export async function removeWorktree(r, repoPath, worktreePath) {
+    await r.run(['git', '-C', repoPath, 'worktree', 'remove', worktreePath, '--force']);
 }
-export async function isGitRepo(dirPath) {
+export async function isGitRepo(r, dirPath) {
     try {
-        await execa('git', ['-C', dirPath, 'rev-parse', '--git-dir'], { stdio: 'pipe' });
+        await r.exec(['git', '-C', dirPath, 'rev-parse', '--git-dir']);
         return true;
     }
     catch {

package/dist/runner.d.ts

@@ -0,0 +1,14 @@
+export interface Runner {
+    exec(args: string[]): Promise<{
+        stdout: string;
+    }>;
+    run(args: string[]): Promise<void>;
+    exists(remotePath: string): Promise<boolean>;
+    isDirectory(remotePath: string): Promise<boolean>;
+    readdir(remotePath: string): Promise<string[]>;
+    mkdir(remotePath: string): Promise<void>;
+    rm(remotePath: string): Promise<void>;
+    rmdir(remotePath: string): Promise<void>;
+    isRemote: boolean;
+}
+export declare function createRunner(machine?: string): Runner;

package/dist/runner.js

@@ -0,0 +1,111 @@
+import { execa } from 'execa';
+import fs from 'node:fs';
+function parseSshHost(machine) {
+    // "ssh://bytedance" → "bytedance"
+    return machine.replace(/^ssh:\/\//, '');
+}
+function shellEscape(arg) {
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+export function createRunner(machine) {
+    if (!machine) {
+        return createLocalRunner();
+    }
+    return createSshRunner(parseSshHost(machine));
+}
+function createLocalRunner() {
+    return {
+        isRemote: false,
+        async exec(args) {
+            const { stdout } = await execa(args[0], args.slice(1), { stdio: 'pipe' });
+            return { stdout };
+        },
+        async run(args) {
+            console.log(`  $ ${args.join(' ')}`);
+            const result = await execa(args[0], args.slice(1), { all: true }).catch(err => {
+                if (err.all)
+                    process.stderr.write(err.all + '\n');
+                throw err;
+            });
+            if (result.all)
+                process.stdout.write(result.all + '\n');
+        },
+        async exists(p) {
+            return fs.existsSync(p);
+        },
+        async isDirectory(p) {
+            try {
+                return fs.statSync(p).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        async readdir(p) {
+            return fs.readdirSync(p);
+        },
+        async mkdir(p) {
+            await fs.promises.mkdir(p, { recursive: true });
+        },
+        async rm(p) {
+            fs.rmSync(p, { recursive: true, force: true });
+        },
+        async rmdir(p) {
+            fs.rmdirSync(p);
+        },
+    };
+}
+function createSshRunner(host) {
+    function sshArgs(args) {
+        const remoteCmd = args.map(shellEscape).join(' ');
+        return [host, remoteCmd];
+    }
+    return {
+        isRemote: true,
+        async exec(args) {
+            const { stdout } = await execa('ssh', sshArgs(args), { stdio: 'pipe' });
+            return { stdout };
+        },
+        async run(args) {
+            console.log(`  $ [${host}] ${args.join(' ')}`);
+            const result = await execa('ssh', sshArgs(args), { all: true }).catch(err => {
+                if (err.all)
+                    process.stderr.write(err.all + '\n');
+                throw err;
+            });
+            if (result.all)
+                process.stdout.write(result.all + '\n');
+        },
+        async exists(p) {
+            try {
+                await execa('ssh', [host, `test -e ${shellEscape(p)}`], { stdio: 'pipe' });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async isDirectory(p) {
+            try {
+                await execa('ssh', [host, `test -d ${shellEscape(p)}`], { stdio: 'pipe' });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async readdir(p) {
+            const { stdout } = await execa('ssh', [host, `ls ${shellEscape(p)}`], { stdio: 'pipe' });
+            return stdout.trim().split('\n').filter(l => l.length > 0);
+        },
+        async mkdir(p) {
+            await execa('ssh', [host, `mkdir -p ${shellEscape(p)}`], { stdio: 'pipe' });
+        },
+        async rm(p) {
+            await execa('ssh', [host, `rm -rf ${shellEscape(p)}`], { stdio: 'pipe' });
+        },
+        async rmdir(p) {
+            await execa('ssh', [host, `rmdir ${shellEscape(p)}`], { stdio: 'pipe' });
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakakala/kgit",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Git worktree workspace manager",
   "type": "module",
   "bin": {

package/dist/commands/cd.d.ts

@@ -1 +0,0 @@
-export declare function cdCommand(workspace: string, project?: string): void;

package/dist/commands/cd.js

@@ -1,14 +0,0 @@
-import path from 'node:path';
-import fs from 'node:fs';
-import { loadConfig } from '../config.js';
-export function cdCommand(workspace, project) {
-    const config = loadConfig();
-    const targetPath = project
-        ? path.join(config.workspace, workspace, project)
-        : path.join(config.workspace, workspace);
-    if (!fs.existsSync(targetPath)) {
-        process.stderr.write(`Error: path does not exist: ${targetPath}\n`);
-        process.exit(1);
-    }
-    process.stdout.write(targetPath);
-}