@1yefuwang1/dsh-worktrees 0.0.0-stage → 0.2.13

package/dist/runtime.js

@@ -0,0 +1,123 @@
+import { realpath } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+import { WorktreeError, redact } from './errors.js';
+export function capability(ctx, name) {
+    return ctx.get(name);
+}
+export function required(ctx, name) {
+    const result = capability(ctx, name);
+    if (result === undefined)
+        throw new WorktreeError('MISSING_CAPABILITY', `The ${name} capability is not mounted in the caller's composition.`);
+    return result;
+}
+export function policyOf(agent) {
+    return required(agent.ctx, 'sandboxPolicy').resolve({ session: agent.session });
+}
+export function requireFullAccess(agent) {
+    if (policyOf(agent).mode !== 'danger-full-access')
+        throw new WorktreeError('FULL_ACCESS_REQUIRED', 'This operation writes across the worktree and shared Git metadata. Select full access through the existing permission control, then retry; no permission is expanded automatically.');
+}
+export function planBlocksMutation(agent) {
+    const plan = capability(agent.ctx, 'planMode')?.get(agent);
+    return plan?.active === true || plan?.pending === true;
+}
+export async function localProjectPath(agent, requested, signal) {
+    const cwd = agent.session.header.cwd;
+    if (cwd === undefined)
+        throw new WorktreeError('NO_WORKSPACE', 'Select a project before using worktrees.');
+    const path = requested === undefined ? cwd : isAbsolute(requested) ? requested : resolve(cwd, requested);
+    const fs = required(agent.ctx, 'fs');
+    const target = await fs.resolve(path, { cwd, signal });
+    const mapped = fs.processPathFromHostPath(path);
+    if (mapped === undefined || resolve(mapped) !== resolve(fs.processPath(target)))
+        throw new WorktreeError('UNSUPPORTED_PROVIDER', 'Worktree management currently requires a local filesystem and subprocess execution world.');
+    return realpath(path);
+}
+function collect(stream, limit, controller) {
+    if (stream === undefined)
+        return Promise.reject(new WorktreeError('PROCESS_PROTOCOL', 'The subprocess provider did not expose the requested output pipe.'));
+    return new Promise((fulfill, reject) => {
+        const chunks = [];
+        let bytes = 0;
+        let failed = false;
+        const data = (chunk) => {
+            const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            bytes += value.length;
+            if (bytes > limit) {
+                if (!failed) {
+                    failed = true;
+                    const error = new WorktreeError('OUTPUT_LIMIT', 'Git output exceeded its bound; no truncated result is accepted.');
+                    controller.abort(error);
+                    reject(error);
+                }
+            }
+            else if (!failed)
+                chunks.push(value);
+        };
+        const finish = () => { cleanup(); if (!failed)
+            fulfill(Buffer.concat(chunks)); };
+        const error = (reason) => { cleanup(); if (!failed)
+            reject(reason); };
+        const cleanup = () => { stream.off('data', data); stream.off('end', finish); stream.off('close', finish); stream.off('error', error); };
+        stream.on('data', data);
+        stream.once('end', finish);
+        stream.once('close', finish);
+        stream.once('error', error);
+    });
+}
+/** No native spawn fallback: every production Git command uses the caller's managed capabilities. */
+export function createExecutor(agent, config, shutdown) {
+    const subprocess = required(agent.ctx, 'subprocess');
+    return async (spec) => {
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeout = setTimeout(() => { timedOut = true; controller.abort(new WorktreeError('TIMEOUT', 'The Git command exceeded its deadline.')); }, spec.timeoutMs ?? config.commandTimeoutMs);
+        const signals = [controller.signal, spec.signal, shutdown].filter((s) => s !== undefined);
+        const signal = AbortSignal.any(signals);
+        let handle;
+        try {
+            const executable = await subprocess.resolveExecutable(config.gitExecutable, spec.env, signal);
+            let argv = [executable, ...spec.args];
+            const policy = policyOf(agent);
+            if (policy.mode !== 'danger-full-access') {
+                const sandbox = required(agent.ctx, 'sandbox');
+                const confined = await sandbox.confine(argv, policy, signal);
+                if (confined.enforcement !== 'full')
+                    throw new WorktreeError('INCOMPLETE_SANDBOX', 'The available sandbox cannot fully enforce this operation.');
+                argv = confined.argv;
+            }
+            handle = subprocess.spawn({ argv, cwd: spec.cwd, env: spec.env, signal, graceMs: 1500, stdio: { stdin: spec.stdin === undefined ? 'ignore' : 'pipe', stdout: 'pipe', stderr: 'pipe' } });
+            const stdout = collect(handle.stdout, spec.maxBytes ?? 65536, controller);
+            const stderr = collect(handle.stderr, 65536, controller);
+            if (spec.stdin !== undefined) {
+                if (handle.stdin === undefined)
+                    throw new WorktreeError('PROCESS_PROTOCOL', 'The subprocess provider did not expose its input pipe.');
+                handle.stdin.on('error', () => undefined);
+                handle.stdin.end(typeof spec.stdin === 'string' ? spec.stdin : Buffer.from(spec.stdin));
+            }
+            const [out, err, outcome] = await Promise.all([stdout, stderr, handle.done]);
+            if (signal.aborted)
+                throw timedOut ? new WorktreeError('TIMEOUT', 'The Git command exceeded its deadline.') : new WorktreeError('CANCELLED', 'Git was cancelled; committed effects may remain.');
+            if (!await handle.waitForExit(signal))
+                throw new WorktreeError('PROCESS_NOT_QUIESCENT', 'The provider could not confirm that the Git process range exited.');
+            if (outcome.exitCode === null || !(spec.allowedExitCodes ?? [0]).includes(outcome.exitCode))
+                throw new WorktreeError('GIT_FAILED', `Git failed${outcome.exitCode === null ? '' : ` (${outcome.exitCode})`}: ${redact(err.toString('utf8')) || 'no diagnostic'}`);
+            return { stdout: out, stderr: err, exitCode: outcome.exitCode };
+        }
+        catch (error) {
+            handle?.terminate();
+            if (handle !== undefined) {
+                await handle.waitForExit(AbortSignal.timeout(5000)).catch(() => false);
+                handle.stdout?.destroy();
+                handle.stderr?.destroy();
+                handle.stdin?.destroy();
+            }
+            if (timedOut)
+                throw new WorktreeError('TIMEOUT', 'The Git command exceeded its deadline.');
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    };
+}

package/dist/schema.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { WorktreeAction, WorktreeRequest } from './types.js';
+export declare const ACTIONS: readonly ["list", "status", "branches", "create", "start", "branch", "protect", "preview", "export", "handoff", "archive"];
+export declare const requestSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        create: "create";
+        handoff: "handoff";
+        list: "list";
+        status: "status";
+        branches: "branches";
+        start: "start";
+        branch: "branch";
+        protect: "protect";
+        preview: "preview";
+        export: "export";
+        archive: "archive";
+    }>;
+    repoPath: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    operationId: z.ZodOptional<z.ZodString>;
+    remote: z.ZodOptional<z.ZodString>;
+    remoteIdentity: z.ZodOptional<z.ZodString>;
+    remoteBranch: z.ZodOptional<z.ZodString>;
+    sourceSessionId: z.ZodOptional<z.ZodString>;
+    sessionMode: z.ZodOptional<z.ZodEnum<{
+        new: "new";
+        continue: "continue";
+    }>>;
+    requireBlankSource: z.ZodOptional<z.ZodBoolean>;
+    settingsHash: z.ZodOptional<z.ZodString>;
+    firstPrompt: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    folderId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    protected: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    previewId: z.ZodOptional<z.ZodString>;
+    targetPath: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare function parseRequest(value: unknown): WorktreeRequest;
+export declare function parseCommand(raw: string): WorktreeRequest;
+export declare function hashValue(value: unknown): string;
+export declare const mutationActions: Set<WorktreeAction>;
+export declare const fullAccessActions: Set<WorktreeAction>;
+/** Zod attaches non-JSON ~standard helpers; the tool registry requires a plain lossless JSON snapshot. */
+export declare const parameterSchema: Record<string, unknown>;

package/dist/schema.js

@@ -0,0 +1,86 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { WorktreeError } from './errors.js';
+export const ACTIONS = ['list', 'status', 'branches', 'create', 'start', 'branch', 'protect', 'preview', 'export', 'handoff', 'archive'];
+const text = z.string().min(1).max(4096);
+const id = z.string().uuid();
+export const requestSchema = z.object({
+    action: z.enum(ACTIONS), repoPath: text.optional(), id: id.optional(), operationId: id.optional(),
+    remote: text.optional(), remoteIdentity: text.optional(), remoteBranch: text.optional(),
+    sourceSessionId: z.string().min(1).max(256).optional(), sessionMode: z.enum(['new', 'continue']).optional(),
+    requireBlankSource: z.boolean().optional(), settingsHash: z.string().max(128).optional(),
+    firstPrompt: z.string().max(65536).describe('Initial task text for automatic naming; only create accepts it.').optional(),
+    projectId: id.describe('Logical project ID from workspace_project list; pair with folderId on create.').optional(),
+    folderId: z.string().min(1).max(256).describe('Project folder ID from workspace_project list; pair with projectId on create.').optional(),
+    name: text.optional(), protected: z.boolean().optional(), archived: z.boolean().optional(),
+    previewId: id.optional(), targetPath: text.optional(), query: z.string().max(256).optional(),
+    cursor: z.string().max(512).optional(), limit: z.number().int().min(1).max(100).optional(), includeArchived: z.boolean().optional(),
+}).strict();
+const fields = {
+    list: ['repoPath', 'cursor', 'limit', 'includeArchived'],
+    status: ['repoPath', 'id', 'operationId'],
+    branches: ['repoPath', 'remote', 'remoteIdentity', 'query', 'cursor', 'limit'],
+    create: ['repoPath', 'operationId', 'remote', 'remoteIdentity', 'remoteBranch', 'sourceSessionId', 'sessionMode', 'requireBlankSource', 'settingsHash', 'firstPrompt', 'projectId', 'folderId'],
+    start: ['id', 'sourceSessionId', 'sessionMode'],
+    branch: ['id', 'name'], protect: ['id', 'protected'],
+    preview: ['id', 'sourceSessionId', 'targetPath'], export: ['previewId'],
+    handoff: ['id', 'previewId', 'operationId'], archive: ['id', 'archived'],
+};
+export function parseRequest(value) {
+    const parsed = requestSchema.safeParse(value);
+    if (!parsed.success)
+        throw new WorktreeError('INVALID_REQUEST', parsed.error.issues.map(i => `${i.path.join('.') || 'request'}: ${i.message}`).join('; '));
+    const request = parsed.data;
+    for (const key of Object.keys(request))
+        if (key !== 'action' && !fields[request.action].includes(key))
+            throw new WorktreeError('INVALID_REQUEST', `${request.action} does not accept ${key}.`);
+    const required = {
+        create: ['operationId', 'remote', 'remoteBranch'], start: ['id'], branch: ['id', 'name'], protect: ['id', 'protected'],
+        preview: ['id'], export: ['previewId'], handoff: ['id', 'previewId', 'operationId'], archive: ['id'], branches: ['remote'],
+    };
+    for (const key of required[request.action] ?? [])
+        if (request[key] === undefined)
+            throw new WorktreeError('INVALID_REQUEST', `${request.action} requires ${key}.`);
+    if (request.action === 'status' && request.id !== undefined && request.operationId !== undefined)
+        throw new WorktreeError('INVALID_REQUEST', 'Status accepts either id or operationId, not both.');
+    if ((request.projectId === undefined) !== (request.folderId === undefined))
+        throw new WorktreeError('INVALID_REQUEST', 'Supply projectId and folderId together on create.');
+    return request;
+}
+export function parseCommand(raw) {
+    const line = raw.trim();
+    if (line === '')
+        return { action: 'list' };
+    try {
+        if (line.startsWith('{'))
+            return parseRequest(JSON.parse(line));
+        const match = /^([a-z]+)(?:\s+([\s\S]+))?$/u.exec(line);
+        if (match === null)
+            throw new WorktreeError('INVALID_REQUEST', 'Use /worktree <action> [JSON arguments].');
+        const args = match[2] === undefined ? {} : JSON.parse(match[2]);
+        if (args === null || typeof args !== 'object' || Array.isArray(args))
+            throw new WorktreeError('INVALID_REQUEST', 'Arguments must be a JSON object.');
+        if ('action' in args)
+            throw new WorktreeError('INVALID_REQUEST', 'Supply action once, before the JSON arguments.');
+        return parseRequest({ ...args, action: match[1] });
+    }
+    catch (error) {
+        if (error instanceof WorktreeError)
+            throw error;
+        throw new WorktreeError('INVALID_REQUEST', 'Arguments must be valid JSON.');
+    }
+}
+export function hashValue(value) {
+    const canonical = (input) => {
+        if (Array.isArray(input))
+            return input.map(canonical);
+        if (input !== null && typeof input === 'object')
+            return Object.fromEntries(Object.entries(input).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, canonical(v)]));
+        return input;
+    };
+    return createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex');
+}
+export const mutationActions = new Set(['create', 'start', 'branch', 'protect', 'handoff', 'archive']);
+export const fullAccessActions = new Set(['create', 'start', 'branch', 'preview', 'export', 'handoff']);
+/** Zod attaches non-JSON ~standard helpers; the tool registry requires a plain lossless JSON snapshot. */
+export const parameterSchema = JSON.parse(JSON.stringify(z.toJSONSchema(requestSchema)));

package/dist/service.d.ts

@@ -0,0 +1,98 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type SessionEvent } from '@deepseek-ai/dsh-session';
+import { GitOperations } from './git.js';
+import { localProjectPath } from './runtime.js';
+import { SessionBootstrap } from './sessions.js';
+import type { WorktreeStore } from './store.js';
+import type { ProjectController } from './projects.js';
+import type { CheckoutState, WorktreeConfig, WorktreeRecord, WorktreeRequest, WorktreeSetupProgress } from './types.js';
+export interface Invocation {
+    agent: Agent;
+    origin: 'tool' | 'command' | 'ui';
+    signal: AbortSignal;
+    /** Internal observer only: cannot authorize operations; failures are ignored. */
+    onProgress?: (progress: WorktreeSetupProgress) => void;
+    /** Internal admission snapshot only; execute always replaces caller-supplied values. */
+    capturedRoot?: string;
+}
+type GitApi = Pick<GitOperations, 'discover' | 'remotes' | 'branches' | 'create' | 'verify' | 'status' | 'createBranch' | 'renameBranch' | 'fingerprint' | 'snapshot' | 'apply'>;
+type BootstrapApi = Pick<SessionBootstrap, 'actor' | 'isLive' | 'settings' | 'assertBlank' | 'create' | 'close'>;
+export interface ControllerDependencies {
+    git?: (actor: Agent, signal: AbortSignal, guard: () => void) => GitApi;
+    bootstrap?: BootstrapApi;
+    /** Live destination setting for newly admitted creates only; other roots stay static. */
+    worktreeRoot?: () => string;
+    localPath?: typeof localProjectPath;
+    onNamingEligible?: (agent: Agent) => void;
+    projects?: Pick<ProjectController, 'resolveFolder' | 'folderForPath' | 'selectionForWorktree' | 'ensureFolder' | 'recordThread' | 'bindingFor'>;
+}
+/** Validate before any filesystem/Git/naming effects; legacy plain configs may be relative. */
+export declare function resolveWorktreeRoot(value: unknown, allowRelative?: boolean): string;
+/** Caller-authorized operations; shared Git metadata is serialized per canonical common directory. */
+export declare class WorktreeController {
+    private readonly owner;
+    private readonly config;
+    private readonly store;
+    private readonly dependencies;
+    private readonly bootstrap;
+    private readonly shutdown;
+    private readonly queues;
+    private readonly flights;
+    private readonly statuses;
+    private readonly previews;
+    private readonly namingPreparations;
+    private generation;
+    private readonly cursors;
+    private closed;
+    constructor(owner: Context, config: WorktreeConfig, store: WorktreeStore, dependencies?: ControllerDependencies);
+    records(): WorktreeRecord[];
+    cachedStatus(id: string): CheckoutState | undefined;
+    execute(request: WorktreeRequest, invocation: Invocation): Promise<unknown>;
+    private namingTask;
+    skipFirstMessageName(id: string, reason: string): Promise<void>;
+    prepareFirstMessageName(id: string, agent: Agent, event: SessionEvent<'user/message'> | undefined, signal: AbortSignal): Promise<void>;
+    private namingInvocation;
+    private messageForNaming;
+    private prepareName;
+    finishFirstMessageName(id: string, agent: Agent, signal: AbortSignal): Promise<void>;
+    private namingMaintenance;
+    private finishName;
+    close(): Promise<void>;
+    private guard;
+    private git;
+    private local;
+    private projectSelection;
+    private assertProject;
+    private bindThread;
+    private queued;
+    private record;
+    private usable;
+    private putRecord;
+    private putOperation;
+    private progress;
+    private operationResult;
+    private cursor;
+    private nextCursor;
+    private run;
+    private status;
+    private branches;
+    private normalizedCreate;
+    private sameSettings;
+    private newOperation;
+    private phase;
+    private receipt;
+    private journalFailure;
+    private create;
+    private start;
+    private candidates;
+    private checkIdle;
+    private checkClaimed;
+    private claims;
+    private sourceIn;
+    private preview;
+    private previewById;
+    private exportPatch;
+    private handoff;
+}
+export {};