@antst/dashi 0.1.0-alpha.5

package/lib/clipboard-image.js

@@ -0,0 +1,74 @@
+import { spawn } from 'node:child_process';
+import { draftImage } from './image-input.js';
+const APPLE_SCRIPT = `
+ObjC.import('AppKit')
+const pasteboard = $.NSPasteboard.generalPasteboard
+let data = pasteboard.dataForType('public.png')
+if (!data) {
+  const tiff = pasteboard.dataForType('public.tiff')
+  if (tiff) {
+    const image = $.NSBitmapImageRep.imageRepWithData(tiff)
+    if (image) data = image.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $())
+  }
+}
+if (!data) $.exit(2)
+console.log(ObjC.unwrap(data.base64EncodedStringWithOptions(0)))
+`.trim();
+function capture(command, args, base64, path) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            ...(path === undefined ? {} : { env: { ...process.env, PATH: path } }),
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const chunks = [];
+        child.stdout.on('data', (chunk) => { chunks.push(chunk); });
+        child.once('error', error => {
+            if (error.code === 'ENOENT')
+                resolve({ found: false });
+            else
+                reject(error);
+        });
+        child.once('close', code => {
+            if (code !== 0)
+                return resolve({ found: true });
+            const output = Buffer.concat(chunks);
+            if (output.length === 0)
+                return resolve({ found: true });
+            if (!base64)
+                return resolve({ found: true, output: new Uint8Array(output) });
+            try {
+                const decoded = Buffer.from(output.toString('utf8').trim(), 'base64');
+                resolve({ found: true, ...(decoded.length === 0 ? {} : { output: new Uint8Array(decoded) }) });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+/** Read a PNG from an installed platform clipboard helper. */
+export async function readClipboardImage(platform = process.platform, path) {
+    const attempts = platform === 'darwin'
+        ? [
+            ['pngpaste', ['-'], false],
+            ['osascript', ['-l', 'JavaScript', '-e', APPLE_SCRIPT], true],
+        ]
+        : platform === 'linux'
+            ? [
+                ['wl-paste', ['--no-newline', '--type', 'image/png'], false],
+                ['xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o'], false],
+            ]
+            : [];
+    let helperFound = false;
+    for (const [command, args, base64] of attempts) {
+        const result = await capture(command, args, base64, path);
+        helperFound ||= result.found;
+        if (result.output !== undefined)
+            return draftImage(result.output, 'image/png', 'clipboard.png', 'clipboard');
+    }
+    if (attempts.length === 0)
+        throw new Error('Clipboard image paste is supported on Linux and macOS.');
+    throw new Error(helperFound
+        ? 'The clipboard does not contain a PNG image.'
+        : `Clipboard image paste needs ${platform === 'darwin' ? 'pngpaste or osascript' : 'wl-paste or xclip'}.`);
+}

package/lib/completion-trigger.d.ts

@@ -0,0 +1,2 @@
+export declare function slashCompletionQuery(input: string): string | undefined;
+export declare function hasCompletionTrigger(input: string, caret: number): boolean;

package/lib/completion-trigger.js

@@ -0,0 +1,7 @@
+import { detectAtTrigger } from './at-trigger.js';
+export function slashCompletionQuery(input) {
+    return /^\/([a-z0-9_-]*)$/u.exec(input)?.[1];
+}
+export function hasCompletionTrigger(input, caret) {
+    return slashCompletionQuery(input) !== undefined || detectAtTrigger(input, caret) !== undefined;
+}

package/lib/external-editor.d.ts

@@ -0,0 +1,2 @@
+/** Edit one draft through the user's terminal editor and always remove its file. */
+export declare function editDraftExternally(text: string, cwd: string): Promise<string>;

package/lib/external-editor.js

@@ -0,0 +1,39 @@
+import { spawn } from 'node:child_process';
+import { mkdtemp, readFile, rm, rmdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+function runEditor(command, file, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('/bin/sh', ['-c', `exec ${command} "$1"`, 'dashi-editor', file], {
+            cwd, stdio: 'inherit',
+        });
+        child.once('error', reject);
+        child.once('exit', (code, signal) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`editor exited with ${code === null ? signal ?? 'unknown status' : `code ${String(code)}`}`));
+        });
+    });
+}
+/** Edit one draft through the user's terminal editor and always remove its file. */
+export async function editDraftExternally(text, cwd) {
+    const command = process.env.VISUAL?.trim() || process.env.EDITOR?.trim();
+    if (command === undefined || command === '')
+        throw new Error('set $VISUAL or $EDITOR to use Ctrl+G');
+    const directory = await mkdtemp(join(tmpdir(), 'dashi-editor-'));
+    const file = join(directory, 'draft.md');
+    try {
+        await writeFile(file, text, { encoding: 'utf8', mode: 0o600 });
+        await runEditor(command, file, cwd);
+        return await readFile(file, 'utf8');
+    }
+    finally {
+        try {
+            await rm(file, { force: true });
+        }
+        finally {
+            await rmdir(directory);
+        }
+    }
+}

package/lib/history-records.d.ts

@@ -0,0 +1,4 @@
+import type { SessionHistoryRecord } from '@deepseek-ai/dsh-api-session-controller';
+import { type SessionEvent } from '@deepseek-ai/dsh-session';
+/** Expand the Controller's compact history wire records to canonical Session events. */
+export declare function eventsFromRecords(records: readonly SessionHistoryRecord[]): SessionEvent[];

package/lib/history-records.js

@@ -0,0 +1,14 @@
+import { decodeStorageRecord } from '@deepseek-ai/dsh-session';
+/** Expand the Controller's compact history wire records to canonical Session events. */
+export function eventsFromRecords(records) {
+    return records.flatMap((record) => {
+        if (record.type === 'event')
+            return [record.event];
+        const encoded = record.event.type === 'chunkrow/text-chunks'
+            ? { type: 'text-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data }
+            : record.event.type === 'chunkrow/reasoning-chunks'
+                ? { type: 'reasoning-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data }
+                : { type: 'tool-call-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data };
+        return decodeStorageRecord(encoded);
+    });
+}

package/lib/image-input.d.ts

@@ -0,0 +1,8 @@
+import type { AttachmentStore, EncodedImageAttachment, ImageAttachmentRef, ImageMediaType } from '@deepseek-ai/dsh-attachment';
+import type { DraftAttachment } from './state.js';
+export declare function isImagePath(path: string): boolean;
+export declare function draftImage(data: Uint8Array, mediaType: ImageMediaType, name: string, path: string): DraftAttachment;
+/** Snapshot explicit user paths into one disposable composer draft. */
+export declare function readDraftImages(cwd: string, paths: readonly string[]): Promise<DraftAttachment[]>;
+export declare function encodeDraftImages(images: readonly DraftAttachment[]): EncodedImageAttachment[];
+export declare function admitDraftImages(attachments: AttachmentStore, images: readonly DraftAttachment[]): Promise<readonly ImageAttachmentRef[]>;

package/lib/image-input.js

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises';
+import { basename, extname, resolve } from 'node:path';
+const MEDIA_TYPES = {
+    '.gif': 'image/gif',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.png': 'image/png',
+    '.webp': 'image/webp',
+};
+export function isImagePath(path) {
+    return MEDIA_TYPES[extname(path).toLocaleLowerCase()] !== undefined;
+}
+export function draftImage(data, mediaType, name, path) {
+    return { bytes: data.byteLength, data, mediaType, name, path };
+}
+/** Snapshot explicit user paths into one disposable composer draft. */
+export async function readDraftImages(cwd, paths) {
+    return Promise.all(paths.map(async (path) => {
+        const absolute = resolve(cwd, path);
+        const mediaType = MEDIA_TYPES[extname(absolute).toLocaleLowerCase()];
+        if (mediaType === undefined) {
+            throw new Error(`unsupported image extension for ${path}; accepted: .png, .jpg, .jpeg, .webp, .gif`);
+        }
+        const data = new Uint8Array(await readFile(absolute));
+        return draftImage(data, mediaType, basename(absolute), absolute);
+    }));
+}
+export function encodeDraftImages(images) {
+    return images.map(image => ({
+        data: Buffer.from(image.data).toString('base64'), mediaType: image.mediaType, name: image.name,
+    }));
+}
+export function admitDraftImages(attachments, images) {
+    return attachments.saveImages(images.map(image => ({
+        data: image.data, mediaType: image.mediaType, name: image.name,
+    })));
+}

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "dashi";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;

package/lib/index.js

@@ -0,0 +1,250 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { exitOnStdinEnd } from '@deepseek-ai/dsh-cmdline';
+import { createTerminalShell } from './application.js';
+import { sessionOverlay } from './catalogs.js';
+import { readClipboardImage } from './clipboard-image.js';
+import { editDraftExternally } from './external-editor.js';
+import { formatSessionList, isSessionId, parseSessionListArgs, sessionMatches, sessionNotFound, } from './session-list.js';
+import { createSessionRuntime } from './session-runtime.js';
+import { TuiRoot } from './tui-root.js';
+export const name = 'dashi';
+export const inject = [
+    'agentPresets', 'agents', 'attachments', 'cmdlineArgs', 'commands', 'fs', 'permissionPresets', 'sessionController',
+    'sandboxPolicy', 'sessionProjections', 'sessionQuery', 'sessions', 'shell', 'skills', 'tools',
+];
+const validatedVersions = JSON.parse(readFileSync(new URL('../validated-dsh-versions.json', import.meta.url), 'utf8'));
+function parseArgs(args) {
+    let accessible = false;
+    let inline = true;
+    let name;
+    let resume;
+    let resumeAll = false;
+    let resumePicker = false;
+    let useContinue = false;
+    const images = [];
+    const prompt = [];
+    for (let index = 0; index < args.length; index++) {
+        const argument = args[index];
+        if (argument === '--accessible')
+            accessible = true;
+        else if (argument === '--inline')
+            inline = true;
+        else if (argument === '--fullscreen')
+            inline = false;
+        else if (argument === '--name' || argument === '--image') {
+            const value = args[++index];
+            if (value === undefined || value === '')
+                return undefined;
+            if (argument === '--name')
+                name = value;
+            else
+                images.push(value);
+        }
+        else if (argument === '--resume' || argument === '-r') {
+            const value = args[index + 1];
+            if (value === '')
+                return undefined;
+            if (value === undefined || value.startsWith('-'))
+                resumePicker = true;
+            else
+                resume = args[++index];
+        }
+        else if (argument === '--all')
+            resumeAll = true;
+        else if (argument === '--continue' || argument === '-c')
+            useContinue = true;
+        else if (argument?.startsWith('-') === true)
+            return undefined;
+        else if (argument !== undefined)
+            prompt.push(argument);
+    }
+    if (resume !== undefined && (resumePicker || useContinue) || resumePicker && useContinue
+        || name !== undefined && (resume !== undefined || resumePicker || useContinue)
+        || resumeAll && resume === undefined && !resumePicker || resumeAll && useContinue)
+        return undefined;
+    return {
+        accessible,
+        continue: useContinue,
+        inline,
+        resumeAll,
+        resumePicker,
+        ...(images.length === 0 ? {} : { images }),
+        ...(name === undefined ? {} : { name }),
+        ...(prompt.length === 0 ? {} : { prompt: prompt.join(' ') }),
+        ...(resume === undefined ? {} : { resume }),
+    };
+}
+function packageVersion(path) {
+    const manifest = JSON.parse(readFileSync(path, 'utf8'));
+    return typeof manifest.version === 'string' ? manifest.version : 'unknown';
+}
+function runningDshVersions() {
+    try {
+        const entry = realpathSync(process.argv[1] ?? '');
+        const manifest = resolve(dirname(entry), '../package.json');
+        const version = packageVersion(manifest);
+        try {
+            return [version, packageVersion(createRequire(manifest).resolve('@deepseek-ai/dsh-base/package.json'))];
+        }
+        catch {
+            return [version, 'unknown'];
+        }
+    }
+    catch {
+        return ['unknown', 'unknown'];
+    }
+}
+function warnDshVersion() {
+    const [version, baseVersion] = runningDshVersions();
+    if (baseVersion !== version) {
+        process.stderr.write(`dashi: warning: DSH ${version} loads @deepseek-ai/dsh-base ${baseVersion}; versions must match\n`);
+    }
+    if (!validatedVersions.includes(version)) {
+        process.stderr.write(`dashi: warning: DSH ${version} is not validated; validated: ${validatedVersions.join(', ')}\n`);
+    }
+}
+function installSessionList(ctx, options, ready, exit) {
+    const abort = new AbortController();
+    let listing;
+    const announce = ready.onReady(() => {
+        warnDshVersion();
+        listing = ctx.sessionController.list({}, abort.signal).then(({ items }) => {
+            const cwd = options.all ? undefined : resolve(options.cwd ?? process.cwd());
+            process.stdout.write(`${formatSessionList(items, cwd, options.json)}\n`);
+            exit(0);
+        }).catch((error) => {
+            process.stderr.write(`dashi: sessions list failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            exit(1);
+        });
+    });
+    ctx.effect(() => async () => {
+        announce();
+        abort.abort();
+        await listing;
+    }, 'dashi.sessions-list');
+}
+export function apply(ctx) {
+    const exit = ctx.get('appExit');
+    const ready = ctx.get('appReady');
+    const cmdline = ctx.get('cmdlineArgs');
+    if (exit === undefined || ready === undefined || cmdline === undefined) {
+        throw new Error('dashi: the launcher must provide ctx.appExit, ctx.appReady, and ctx.cmdlineArgs');
+    }
+    const args = cmdline.get();
+    if (args[0] === 'sessions') {
+        const options = parseSessionListArgs(args);
+        if (options === undefined) {
+            process.stderr.write(`dashi: unsupported arguments: ${args.join(' ')}\n`);
+            exit(2);
+            return;
+        }
+        installSessionList(ctx, options, ready, exit);
+        return;
+    }
+    const parsed = parseArgs(args);
+    if (parsed === undefined) {
+        process.stderr.write(`dashi: unsupported arguments: ${args.join(' ')}\n`);
+        exit(2);
+        return;
+    }
+    const tuiRoot = new TuiRoot(ctx);
+    let shell;
+    let runtime;
+    let boot;
+    const stdoutError = (error) => { void shell?.fail(error); };
+    process.stdout.on('error', stdoutError);
+    const changed = ctx.on('tui/root-changed', (_previous, current) => {
+        if (current === undefined)
+            shell?.dispatch({ type: 'root-cleared' });
+    });
+    const announce = ready.onReady(() => {
+        warnDshVersion();
+        boot = (async () => {
+            const cwd = process.cwd();
+            const makeRuntime = (options) => createSessionRuntime(ctx, options, tuiRoot, action => { shell?.dispatch(action); }, {
+                cancel: id => { shell?.cancelDecision(id); },
+                request: decision => shell?.requestDecision(decision)
+                    ?? Promise.reject(new Error('dashi terminal is not ready')),
+            });
+            const sendPrompt = () => {
+                if (parsed.prompt !== undefined)
+                    shell?.dispatch({ type: 'composer-changed', text: parsed.prompt });
+                if (parsed.prompt !== undefined)
+                    shell?.dispatch({ type: 'submit' });
+            };
+            let pickerItems = parsed.resumePicker
+                ? (await ctx.sessionController.list({}, new AbortController().signal)).items : undefined;
+            if (parsed.resume !== undefined && !isSessionId(parsed.resume)) {
+                const matches = sessionMatches((await ctx.sessionController.list({}, new AbortController().signal)).items, parsed.resume, parsed.resumeAll ? undefined : cwd);
+                const [match] = matches;
+                if (match === undefined)
+                    throw sessionNotFound(parsed.resume);
+                if (matches.length > 1)
+                    pickerItems = matches;
+                else
+                    runtime = await makeRuntime({ ...parsed, cwd, resume: String(match.sessionId) });
+            }
+            else if (!parsed.resumePicker)
+                runtime = await makeRuntime({ ...parsed, cwd });
+            const initial = runtime;
+            shell = createTerminalShell({
+                accessible: parsed.accessible,
+                activateOverlay: async (value) => {
+                    if (runtime !== undefined)
+                        return runtime.activate(value);
+                    if (value.kind !== 'resume')
+                        return;
+                    runtime = await makeRuntime({ ...parsed, continue: false, cwd, resume: value.sessionId });
+                    shell?.dispatch({ type: 'root-bound', cells: runtime.initialCells, hasMore: runtime.initialHasMore,
+                        prompts: runtime.initialPrompts, root: runtime.root });
+                    for (const attachment of runtime.initialAttachments)
+                        shell?.dispatch({ type: 'attachment-added', attachment });
+                    runtime.start();
+                    sendPrompt();
+                },
+                attach: path => runtime?.attach(path) ?? Promise.resolve(undefined),
+                beforeExit: () => runtime?.shutdown() ?? Promise.resolve(),
+                complete: (query, caret) => runtime?.complete(query, caret) ?? Promise.resolve([]),
+                cwd,
+                cyclePermission: () => runtime?.cyclePermission() ?? Promise.resolve(),
+                exit,
+                externalEdit: editDraftExternally,
+                ...(initial === undefined ? {} : {
+                    initialAttachments: initial.initialAttachments, initialCells: initial.initialCells, initialHasMore: initial.initialHasMore,
+                    initialPrompts: initial.initialPrompts, initialRoot: initial.root,
+                }),
+                inline: parsed.inline || parsed.accessible,
+                interrupt: () => { runtime?.interrupt(); },
+                loadHistory: rootId => runtime?.loadHistory(rootId) ?? Promise.resolve(),
+                onReleased: () => { process.stdout.write(`${runtime?.summary ?? ''}\n`); },
+                pasteImage: readClipboardImage,
+                search: (query, rootId) => runtime?.search(query, rootId) ?? Promise.resolve(),
+                submit: (text, mode, attachments) => runtime?.submit(text, mode, attachments),
+            });
+            shell.start();
+            if (pickerItems !== undefined) {
+                shell.dispatch({ type: 'open-overlay', overlay: sessionOverlay(pickerItems, '', parsed.resumeAll ? undefined : cwd) });
+            }
+            else {
+                runtime?.start();
+                sendPrompt();
+            }
+        })().catch(async (error) => {
+            process.stderr.write(`dashi: startup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            await runtime?.shutdown();
+            await shell?.dispose();
+            exit(1);
+        });
+    });
+    ctx.effect(() => async () => {
+        announce();
+        changed();
+        await boot;
+        await runtime?.shutdown();
+        await shell?.dispose();
+        process.stdout.off('error', stdoutError);
+    }, 'dashi.profile-boot');
+    exitOnStdinEnd(ctx, 'dashi.stdin');
+}

package/lib/input.d.ts

@@ -0,0 +1,10 @@
+import { type TUI } from '@earendil-works/pi-tui';
+import type { ComposerCursor, UiAction, ViewState } from './state.js';
+export interface InputBindings {
+    readonly dispatch: (action: UiAction) => void;
+    readonly insertNewline?: () => void;
+    readonly readComposerCursor?: () => ComposerCursor;
+    readonly readState: () => ViewState;
+}
+export declare function caretOffset(text: string, cursor: ComposerCursor): number;
+export declare function installInput(tui: TUI, bindings: InputBindings): () => void;