@openturtle/cli 0.3.0

package/dist/core/web-auth.js

@@ -0,0 +1,115 @@
+import { spawn } from 'node:child_process';
+import { ApiClient } from './api-client.js';
+import { readAuth, writeAuth } from './auth.js';
+import { DEFAULT_SERVER_URL } from './defaults.js';
+const DEFAULT_LOCAL_WEB_PORT = '5174';
+export async function loginWithWeb(options, dependencies = {}) {
+    const current = readAuth(options.homeDir);
+    const server = normalizeServer(options.server || current.server || DEFAULT_SERVER_URL);
+    const verificationUri = resolveWebLoginUrl(server, options.webUrl);
+    const client = dependencies.client || new ApiClient({ server, homeDir: options.homeDir });
+    const sleep = dependencies.sleep || ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+    const now = dependencies.now || Date.now;
+    const open = dependencies.openBrowser || openBrowser;
+    const device = await client.post('/api/auth/cli/device', {
+        client_name: 'OpenTurtle CLI',
+        verification_uri: verificationUri,
+    });
+    dependencies.onDeviceCreated?.(device);
+    const browserOpened = options.noOpen ? false : await open(device.verification_uri_complete);
+    const expiresAt = now() + device.expires_in * 1000;
+    let intervalSeconds = Math.max(1, device.interval || 2);
+    while (now() < expiresAt) {
+        const result = await client.post('/api/auth/cli/token', {
+            device_code: device.device_code,
+        });
+        if (result.status === 'authorization_pending') {
+            intervalSeconds = Math.max(1, result.interval || intervalSeconds);
+            await sleep(intervalSeconds * 1000);
+            continue;
+        }
+        const token = result.access_token || '';
+        const refreshToken = result.refresh_token || '';
+        if (!token || !refreshToken) {
+            throw new Error('Web login response did not include access and refresh tokens');
+        }
+        writeAuth({
+            server,
+            token,
+            refreshToken,
+            username: result.username,
+            teamId: result.team_id,
+        }, options.homeDir);
+        return {
+            logged_in: true,
+            server,
+            username: result.username || null,
+            team_id: result.team_id || null,
+            browser_opened: browserOpened,
+        };
+    }
+    throw new Error('Web login expired before authorization completed');
+}
+export function resolveWebLoginUrl(server, override) {
+    if (override)
+        return normalizeWebUrl(override);
+    const apiUrl = new URL(normalizeServer(server));
+    if (apiUrl.hostname === '127.0.0.1' || apiUrl.hostname === 'localhost' || apiUrl.hostname === '::1') {
+        apiUrl.port = DEFAULT_LOCAL_WEB_PORT;
+        apiUrl.pathname = '/cli-auth';
+        apiUrl.search = '';
+        apiUrl.hash = '';
+        return apiUrl.toString();
+    }
+    apiUrl.pathname = `${apiUrl.pathname.replace(/\/$/, '')}/cli-auth`.replace(/\/+/g, '/');
+    apiUrl.search = '';
+    apiUrl.hash = '';
+    return apiUrl.toString();
+}
+export async function openBrowser(url, platform = process.platform, spawnBrowser = spawn) {
+    const launch = browserLaunchCommand(url, platform);
+    if (!launch)
+        return false;
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawnBrowser(launch.command, launch.args, {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+        }
+        catch {
+            resolve(false);
+            return;
+        }
+        child.once('spawn', () => {
+            child.unref();
+            resolve(true);
+        });
+        child.once('error', () => resolve(false));
+    });
+}
+export function browserLaunchCommand(url, platform = process.platform) {
+    if (platform === 'darwin')
+        return { command: 'open', args: [url] };
+    if (platform === 'linux')
+        return { command: 'xdg-open', args: [url] };
+    if (platform === 'win32')
+        return { command: 'cmd', args: ['/c', 'start', '', url] };
+    return null;
+}
+function normalizeServer(value) {
+    const url = new URL(value);
+    url.pathname = url.pathname.replace(/\/$/, '') || '/';
+    url.search = '';
+    url.hash = '';
+    return url.toString().replace(/\/$/, '');
+}
+function normalizeWebUrl(value) {
+    const url = new URL(value);
+    if (!['http:', 'https:'].includes(url.protocol)) {
+        throw new Error('--web-url must use http or https');
+    }
+    return url.toString();
+}

package/dist/index.js

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { Command } from 'commander';
+import { registerCollaborationCommands } from './commands/collaboration.js';
+import { ingestRawHook, recordGitPostCommit } from './commands/hook.js';
+import { doctor, draftDailyReport, createResourceCommands } from './commands/resources.js';
+import { ApiClient, ApiError } from './core/api-client.js';
+import { clearAuth, readAuth, redactToken, writeAuth } from './core/auth.js';
+import { DEFAULT_SERVER_URL } from './core/defaults.js';
+import { findWorkspaceRoot } from './core/paths.js';
+import { initProjectStore } from './core/store.js';
+import { cliVersion } from './core/version.js';
+import { loginWithWeb } from './core/web-auth.js';
+import { installClaude, installCodex, installCursor, installKiro, installQoder, uninstallClaude, uninstallCodex, uninstallCursor, uninstallKiro, uninstallQoder, } from './installers/agents.js';
+import { installGitHook, uninstallGitHook } from './installers/git.js';
+import { uninstallAllLocalState } from './installers/uninstall.js';
+import { serveMcp } from './mcp/server.js';
+import { candidateHistoryPaths, importHistory } from './watchers/importers.js';
+const program = new Command();
+program
+    .name('ot')
+    .description('OpenTurtle collaboration, knowledge, meeting, and local agent CLI')
+    .version(cliVersion());
+program.option('-j, --json', 'emit machine-readable JSON, including errors');
+program
+    .command('init')
+    .option('--update-gitignore', 'append .openturtle-cli to .gitignore')
+    .action(action((options) => {
+    const workspace = findWorkspaceRoot();
+    const store = initProjectStore(workspace);
+    if (options.updateGitignore)
+        updateGitignore(workspace);
+    print({ initialized: true, project_dir: store.dir });
+}));
+program
+    .command('doctor')
+    .option('--target <target>')
+    .option('--json')
+    .action(action(async (options) => {
+    const result = doctor(findWorkspaceRoot(), options.target);
+    const api = await new ApiClient().probe();
+    print({ ...result, api }, options.json);
+}));
+const auth = program.command('auth');
+auth
+    .command('login')
+    .option('--server <url>')
+    .option('--token <jwt>')
+    .option('--username <name>')
+    .option('--password <password>')
+    .option('--web', 'log in through OpenTurtle Web Admin')
+    .option('--web-url <url>', 'override the Web authorization page URL')
+    .option('--no-open', 'print the authorization URL without opening a browser')
+    .action(action(async (options) => {
+    if (options.web) {
+        if (options.token || options.username || options.password) {
+            throw new Error('--web cannot be combined with token or password login');
+        }
+        const result = await loginWithWeb({
+            server: options.server,
+            webUrl: options.webUrl,
+            noOpen: options.open === false,
+        }, {
+            onDeviceCreated: (session) => {
+                process.stderr.write(`Open ${session.verification_uri_complete}\n`);
+                process.stderr.write(`Device code: ${session.user_code}\n`);
+            },
+        });
+        print(result);
+        return;
+    }
+    if (options.webUrl || options.open === false) {
+        throw new Error('--web-url and --no-open require --web');
+    }
+    const server = options.server || DEFAULT_SERVER_URL;
+    if (options.token) {
+        writeAuth({ server, token: options.token, username: options.username });
+        print({ logged_in: true, server, token: redactToken(options.token) });
+        return;
+    }
+    if (!options.username || !options.password) {
+        throw new Error('Use --token or provide --username and --password');
+    }
+    const client = new ApiClient({ server });
+    const result = await client.post('/api/auth/login', {
+        username: options.username,
+        password: options.password,
+    });
+    const token = String(result.access_token || result.token || '');
+    if (!token)
+        throw new Error('Login response did not include token');
+    const refreshToken = String(result.refresh_token || '');
+    writeAuth({
+        server,
+        token,
+        refreshToken: refreshToken || undefined,
+        username: options.username,
+    });
+    print({ logged_in: true, server, token: redactToken(token) });
+}));
+auth.command('status').action(action(() => {
+    const current = readAuth();
+    print({
+        server: current.server || null,
+        username: current.username || null,
+        team_id: current.teamId || null,
+        token: redactToken(current.token),
+        has_refresh_token: Boolean(current.refreshToken),
+        logged_in: Boolean(current.token),
+    });
+}));
+auth.command('logout').action(action(() => {
+    clearAuth();
+    print({ logged_out: true });
+}));
+program
+    .command('install')
+    .option('--target <target>')
+    .option('--scope <scope>', 'project|user', 'project')
+    .option('--with-agent-hooks')
+    .action(action((options) => {
+    requireOption(options.target, '--target');
+    const workspace = findWorkspaceRoot();
+    for (const target of expandTargets(options.target)) {
+        installTarget(target, workspace, options.scope, Boolean(options.withAgentHooks));
+    }
+    print({
+        installed: options.target,
+        mcp_server_name: 'ot-cli',
+        with_agent_hooks: Boolean(options.withAgentHooks),
+    });
+}));
+program
+    .command('uninstall')
+    .option('--target <target>')
+    .option('--scope <scope>', 'project|user', 'project')
+    .action(action((options) => {
+    requireOption(options.target, '--target');
+    const workspace = findWorkspaceRoot();
+    for (const target of expandTargets(options.target)) {
+        uninstallTarget(target, workspace, options.scope);
+    }
+    const local_state = options.target === 'all' ? uninstallAllLocalState(workspace) : { removedProjectDir: false };
+    print({ uninstalled: options.target, scope: options.scope, local_state });
+}));
+const hook = program.command('hook');
+hook
+    .command('ingest')
+    .option('--target <target>')
+    .option('--event <event>')
+    .option('--stdin-json')
+    .action(action(async (options) => {
+    requireOption(options.target, '--target');
+    requireOption(options.event, '--event');
+    const stdin = options.stdinJson ? await readStdin() : '{}';
+    const result = ingestRawHook({
+        target: options.target,
+        event: options.event,
+        stdin,
+        workspace: findWorkspaceRoot(),
+    });
+    if (!result.ok)
+        process.exitCode = 0;
+}));
+hook.command('git-post-commit').action(action(() => {
+    recordGitPostCommit(findWorkspaceRoot());
+}));
+hook.command('doctor').action(action(() => print(doctor(findWorkspaceRoot()))));
+program
+    .command('import-history')
+    .option('--target <target>')
+    .action(action((options) => {
+    requireOption(options.target, '--target');
+    const workspace = findWorkspaceRoot();
+    if (options.target === 'all') {
+        print(['claude', 'codex', 'cursor', 'qoder', 'kiro'].map((target) => importHistory(target, workspace)));
+        return;
+    }
+    print(importHistory(options.target, workspace));
+}));
+program
+    .command('watch')
+    .option('--target <target>')
+    .action(action((options) => {
+    requireOption(options.target, '--target');
+    print({
+        target: options.target,
+        watcher_paths: candidateHistoryPaths(options.target),
+        note: 'v1 watch uses import-history polling semantics; native hooks are preferred where supported.',
+    });
+}));
+const resources = createResourceCommands();
+const goals = program.command('goals');
+goals
+    .command('list')
+    .option('--project <id>')
+    .option('--mine')
+    .option('--status <status>')
+    .option('--json')
+    .action(action(async (options) => print(await resources.listGoals({ project_id: options.project, mine: options.mine, status: options.status }), options.json)));
+goals
+    .command('show <goalId>')
+    .option('--json')
+    .action(action(async (goalId, options) => print(await resources.showGoal(goalId), options.json)));
+const todos = program.command('todos');
+todos
+    .command('list')
+    .option('--project <id>')
+    .option('--mine')
+    .option('--status <status>')
+    .option('--json')
+    .action(action(async (options) => print(await resources.listTodos({ project_id: options.project, mine: options.mine, status: options.status }), options.json)));
+todos
+    .command('show <todoId>')
+    .option('--json')
+    .action(action(async (todoId, options) => print(await resources.showTodo(todoId), options.json)));
+todos
+    .command('status <todoId> <status>')
+    .option('--dry-run')
+    .action(action(async (todoId, status, options) => {
+    if (options.dryRun) {
+        print({
+            dry_run: true,
+            request: {
+                method: 'PATCH',
+                path: `/api/todos/${encodeURIComponent(todoId)}/status`,
+                body: { status },
+            },
+        });
+        return;
+    }
+    print(await resources.updateTodoStatus(todoId, status));
+}));
+todos
+    .command('progress <todoId>')
+    .option('--message <text>')
+    .option('--dry-run')
+    .action(action(async (todoId, options) => {
+    requireOption(options.message, '--message');
+    if (options.dryRun) {
+        print({
+            dry_run: true,
+            request: {
+                method: 'PATCH',
+                path: `/api/todos/${encodeURIComponent(todoId)}/progress-description`,
+                body: { progress_description: options.message },
+            },
+        });
+        return;
+    }
+    print(await resources.updateTodoProgress(todoId, options.message));
+}));
+const knowledge = program.command('knowledge');
+knowledge
+    .command('list')
+    .option('--project <id>')
+    .option('--q <keyword>')
+    .option('--kind <kind>')
+    .option('--status <status>')
+    .option('--space <space>', 'personal|team')
+    .option('--person <name-or-id>')
+    .option('--page <number>', 'page number', Number)
+    .option('--page-size <number>', 'items per page', Number)
+    .option('--json')
+    .action(action(async (options) => print(await resources.listKnowledge(options), options.json)));
+knowledge
+    .command('show <knowledgeId>')
+    .option('--json')
+    .action(action(async (knowledgeId, options) => print(await resources.showKnowledge(knowledgeId), options.json)));
+knowledge
+    .command('search <keyword>')
+    .option('--project <id>')
+    .option('--person <name-or-id>')
+    .option('--scope <scope>', 'team|managed|participating|assigned', 'team')
+    .option('--limit <number>', 'maximum results', Number)
+    .option('--json')
+    .action(action(async (keyword, options) => print(await resources.searchKnowledge(keyword, options), options.json)));
+knowledge
+    .command('sources')
+    .option('--path <path>')
+    .option('--q <keyword>')
+    .option('--json')
+    .action(action(async (options) => print(await resources.listKnowledgeSources({ path: options.path, q: options.q }), options.json)));
+knowledge
+    .command('source <path>')
+    .option('--json')
+    .action(action(async (filePath, options) => print(await resources.readKnowledgeSource(filePath), options.json)));
+const worklogs = program.command('worklogs');
+worklogs
+    .command('list')
+    .option('--today')
+    .option('--window <window>')
+    .option('--json')
+    .action(action(async (options) => print(await resources.listWorklogs(options), options.json)));
+worklogs
+    .command('record')
+    .option('--summary <text>')
+    .option('--type <type>', 'progress|blocker|decision|commit|note|meeting', 'note')
+    .option('--dry-run')
+    .action(action(async (options) => {
+    requireOption(options.summary, '--summary');
+    if (options.dryRun) {
+        print({
+            dry_run: true,
+            request: {
+                method: 'POST',
+                path: '/api/work-logs',
+                body: {
+                    summary: options.summary,
+                    event_type: options.type,
+                    source: 'manual',
+                    metadata: { source_client: 'ot-cli' },
+                },
+            },
+        });
+        return;
+    }
+    print(await resources.recordWorklog(options.summary, options.type));
+}));
+registerCollaborationCommands(program, { goals, todos, knowledge, worklogs }, { print, fatal });
+program
+    .command('report [subcommand]')
+    .description('daily report commands')
+    .allowUnknownOption()
+    .action(action((subcommand) => {
+    if (subcommand === 'draft') {
+        const options = parseSimpleOptions(process.argv.slice(4));
+        print({ path: draftDailyReport(findWorkspaceRoot(), options) });
+        return;
+    }
+    throw new Error('Usage: ot report draft [--today] [--output <path>]');
+}));
+program
+    .command('mcp [subcommand]')
+    .description('MCP server commands')
+    .allowUnknownOption()
+    .action(action(async (subcommand) => {
+    if (subcommand === 'serve') {
+        await serveMcp();
+        return;
+    }
+    throw new Error('Usage: ot mcp serve');
+}));
+if (!runSpecialNestedCommand(process.argv)) {
+    try {
+        program.parse(process.argv);
+    }
+    catch (err) {
+        if (!isExpectedCommanderExit(err))
+            fatal(err);
+    }
+}
+function action(fn) {
+    return (...args) => {
+        Promise.resolve(fn(...args)).catch(fatal);
+    };
+}
+function fatal(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (process.argv.includes('--json') || process.argv.includes('-j')) {
+        const error = err instanceof ApiError
+            ? {
+                code: err.code,
+                message,
+                method: err.method,
+                path: err.path,
+                status: err.status,
+                detail: err.detail,
+            }
+            : { code: 'cli_error', message };
+        process.stderr.write(`${JSON.stringify({ ok: false, error }, null, 2)}\n`);
+    }
+    else {
+        process.stderr.write(`ot: ${message}\n`);
+    }
+    process.exit(1);
+}
+function installTarget(target, workspace, scope, withAgentHooks) {
+    if (target === 'git')
+        installGitHook(workspace);
+    if (target === 'claude')
+        installClaude({ workspace, scope, withAgentHooks });
+    if (target === 'codex')
+        installCodex({ workspace, scope, withAgentHooks });
+    if (target === 'cursor')
+        installCursor({ workspace, scope, withAgentHooks });
+    if (target === 'qoder')
+        installQoder({ workspace, scope, withAgentHooks });
+    if (target === 'kiro')
+        installKiro({ workspace, scope, withAgentHooks });
+}
+function uninstallTarget(target, workspace, scope) {
+    const options = { workspace, scope, withAgentHooks: true };
+    if (target === 'git')
+        uninstallGitHook(workspace);
+    if (target === 'claude')
+        uninstallClaude(options);
+    if (target === 'codex')
+        uninstallCodex(options);
+    if (target === 'cursor')
+        uninstallCursor(options);
+    if (target === 'qoder')
+        uninstallQoder(options);
+    if (target === 'kiro')
+        uninstallKiro(options);
+}
+function requireOption(value, name) {
+    if (value == null || value === '') {
+        throw new Error(`Missing required option ${name}`);
+    }
+}
+function expandTargets(target) {
+    if (target === 'all')
+        return ['git', 'claude', 'codex', 'cursor', 'qoder', 'kiro'];
+    return [target];
+}
+function print(value, asJson = true) {
+    if (asJson) {
+        process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf-8');
+}
+function updateGitignore(workspace) {
+    const gitignorePath = `${workspace}/.gitignore`;
+    const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf-8') : '';
+    if (existing.split(/\r?\n/).includes('.openturtle-cli/'))
+        return;
+    fs.writeFileSync(gitignorePath, `${existing.trimEnd()}${existing.trim() ? '\n' : ''}.openturtle-cli/\n`, 'utf-8');
+}
+function runSpecialNestedCommand(argv) {
+    const [, , first, second, ...rest] = argv;
+    if (first === 'mcp' && second === 'serve') {
+        void serveMcp().catch(fatal);
+        return true;
+    }
+    if (first === 'report' && second === 'draft') {
+        const options = parseSimpleOptions(rest);
+        print({ path: draftDailyReport(findWorkspaceRoot(), options) });
+        process.exit(0);
+        return true;
+    }
+    return false;
+}
+function parseSimpleOptions(args) {
+    const options = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--today')
+            options.today = true;
+        if (arg === '--output') {
+            options.output = args[index + 1];
+            index += 1;
+        }
+    }
+    return options;
+}
+function isExpectedCommanderExit(err) {
+    return Boolean(err &&
+        typeof err === 'object' &&
+        'code' in err &&
+        String(err.code).startsWith('commander.'));
+}