talos-code 0.0.1 → 0.1.0

package/dist/sessions/metadata-store.js

@@ -0,0 +1,160 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { chmod, mkdir, open, readFile, rename, rm, stat } from 'node:fs/promises';
+import path from 'node:path';
+export const SESSION_METADATA_SCHEMA = 'talos.cli.session-metadata.v1';
+export const SESSION_METADATA_MAX_TAGS = 32;
+export const SESSION_METADATA_TAG_MAX_BYTES = 96;
+export const SESSION_METADATA_STORE_MAX_BYTES = 64 * 1024;
+export class SessionMetadataError extends Error {
+    code;
+    constructor(code, message = code) { super(message); this.name = 'SessionMetadataError'; this.code = code; }
+}
+function fail(message = 'Session metadata is invalid.') { throw new SessionMetadataError('SESSION_METADATA_INVALID', message); }
+function sessionId(value) {
+    if (typeof value !== 'string' || !value.trim() || value.length > 512 || /[\0\r\n]/u.test(value))
+        fail('Session id is invalid.');
+    return value;
+}
+function tagValue(value) {
+    if (typeof value !== 'string')
+        fail('Tag is invalid.');
+    const normalized = value.normalize('NFKC').trim().replace(/\s+/gu, ' ').toLowerCase();
+    if (!normalized || /[\u0000-\u001f\u007f-\u009f\u2028\u2029\p{Bidi_Control}\p{Default_Ignorable_Code_Point}]/u.test(normalized) || Buffer.byteLength(normalized, 'utf8') > SESSION_METADATA_TAG_MAX_BYTES)
+        fail('Tag is invalid.');
+    return normalized;
+}
+export const SESSION_METADATA_NAME_MAX = 80;
+function nameValue(value) {
+    if (typeof value !== 'string')
+        fail('Name is invalid.');
+    const normalized = value.normalize('NFKC').trim().replace(/\s+/gu, ' ');
+    if (!normalized || normalized.length > SESSION_METADATA_NAME_MAX || /[\u0000-\u001f\u007f-\u009f\u2028\u2029\p{Bidi_Control}]/u.test(normalized))
+        fail('Name is invalid.');
+    return normalized;
+}
+function timestamp(value) { return typeof value === 'string' && value.length <= 64 && !Number.isNaN(Date.parse(value)); }
+function validate(value, expectedSessionId) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        fail();
+    const row = value;
+    if (row.schema !== SESSION_METADATA_SCHEMA || row.sessionId !== expectedSessionId || typeof row.pinned !== 'boolean' || !timestamp(row.createdAt) || !timestamp(row.updatedAt) || !Array.isArray(row.tags) || row.tags.length > SESSION_METADATA_MAX_TAGS)
+        fail();
+    const tags = [];
+    const seen = new Set();
+    for (const raw of row.tags) {
+        const normalized = tagValue(raw);
+        if (raw !== normalized || seen.has(normalized))
+            fail();
+        seen.add(normalized);
+        tags.push(normalized);
+    }
+    if (row.name !== undefined && nameValue(row.name) !== row.name)
+        fail();
+    return { schema: SESSION_METADATA_SCHEMA, sessionId: expectedSessionId, tags, pinned: row.pinned, ...(row.name !== undefined ? { name: row.name } : {}), createdAt: row.createdAt, updatedAt: row.updatedAt };
+}
+async function privateDir(dirname) { await mkdir(dirname, { recursive: true, mode: 0o700 }); try {
+    await chmod(dirname, 0o700);
+}
+catch (error) {
+    if (process.platform !== 'win32')
+        throw error;
+} }
+async function syncDir(dirname) { try {
+    const handle = await open(dirname, 'r');
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+catch (error) {
+    if (process.platform !== 'win32')
+        throw error;
+} }
+async function atomicWrite(file, body) {
+    const dirname = path.dirname(file);
+    await privateDir(dirname);
+    const temp = path.join(dirname, `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        const handle = await open(temp, 'wx', 0o600);
+        try {
+            await handle.writeFile(body, 'utf8');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temp, file);
+        try {
+            await chmod(file, 0o600);
+        }
+        catch (error) {
+            if (process.platform !== 'win32')
+                throw error;
+        }
+        await syncDir(dirname);
+    }
+    catch (error) {
+        await rm(temp, { force: true }).catch(() => { });
+        if (error instanceof SessionMetadataError)
+            throw error;
+        throw Object.assign(new SessionMetadataError('SESSION_METADATA_WRITE_FAILED', 'Session metadata could not be written atomically.'), { cause: error });
+    }
+}
+export function sessionMetadataRoot(dataRoot) { if (typeof dataRoot !== 'string' || !dataRoot.trim())
+    fail('Data root is invalid.'); return path.join(dataRoot, 'session-metadata'); }
+export function createSessionMetadataStore({ rootDir }) {
+    if (typeof rootDir !== 'string' || !rootDir.trim())
+        fail('Metadata root is invalid.');
+    const fileForSession = (id) => path.join(rootDir, `${createHash('sha256').update(sessionId(id)).digest('hex')}.json`);
+    async function get(idValue) {
+        const id = sessionId(idValue), file = fileForSession(id);
+        let info;
+        try {
+            info = await stat(file);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw Object.assign(new SessionMetadataError('SESSION_METADATA_READ_FAILED'), { cause: error });
+        }
+        if (!info.isFile() || info.size > SESSION_METADATA_STORE_MAX_BYTES)
+            fail();
+        let parsed;
+        try {
+            parsed = JSON.parse(await readFile(file, 'utf8'));
+        }
+        catch {
+            fail('Session metadata is not valid JSON.');
+        }
+        return validate(parsed, id);
+    }
+    async function save(row) {
+        const valid = validate(row, sessionId(row.sessionId));
+        const body = `${JSON.stringify(valid)}\n`;
+        if (Buffer.byteLength(body, 'utf8') > SESSION_METADATA_STORE_MAX_BYTES)
+            throw new SessionMetadataError('SESSION_METADATA_LIMIT', 'Session metadata exceeds its byte budget.');
+        await atomicWrite(fileForSession(valid.sessionId), body);
+        return valid;
+    }
+    async function mutate(idValue, change) {
+        const id = sessionId(idValue), current = await get(id), now = new Date().toISOString();
+        const next = current ? { ...current, tags: [...current.tags] } : { schema: SESSION_METADATA_SCHEMA, sessionId: id, tags: [], pinned: false, createdAt: now, updatedAt: now };
+        change(next);
+        next.updatedAt = now;
+        return save(next);
+    }
+    async function addTag(id, rawTag) { const tag = tagValue(rawTag); return mutate(id, row => { if (row.tags.includes(tag))
+        return; if (row.tags.length >= SESSION_METADATA_MAX_TAGS)
+        throw new SessionMetadataError('SESSION_METADATA_LIMIT', `A session can have at most ${SESSION_METADATA_MAX_TAGS} tags.`); row.tags.push(tag); }); }
+    async function removeTag(id, rawTag) { const tag = tagValue(rawTag); return mutate(id, row => { row.tags = row.tags.filter(value => value !== tag); }); }
+    async function setPinned(id, pinned) { if (typeof pinned !== 'boolean')
+        fail('Pin state is invalid.'); return mutate(id, row => { row.pinned = pinned; }); }
+    /** R5b D2: `null` clears the name. */
+    async function setName(id, name) { const value = name === null ? null : nameValue(name); return mutate(id, row => { if (value === null)
+        delete row.name;
+    else
+        row.name = value; }); }
+    return { fileForSession, get, addTag, removeTag, setPinned, setName };
+}

package/dist/sessions/share.js

@@ -0,0 +1,122 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, open, rename, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { createRedactor, redactObject } from "../diagnostics/redact.js";
+export const SESSION_SHARE_SCHEMA = 'talos.cli.session-share.v1';
+export const SESSION_SHARE_MAX_BYTES = 64 * 1024 * 1024;
+function coded(code, message = code) { return Object.assign(new Error(message), { code }); }
+function textOrNull(value) { return typeof value === 'string' && value.trim() ? value.trim() : null; }
+const WINDOWS_DRIVE_ABSOLUTE = /(?:^|[^A-Za-z0-9])[A-Za-z]:[\\/]/u;
+const WINDOWS_UNC_ABSOLUTE = /(?:^|[^\\])\\\\[^\\\r\n]+\\[^\\\r\n]+/u;
+const FILE_URI_ABSOLUTE = /\bfile:\/\/\//iu;
+const POSIX_ABSOLUTE = /(?<![A-Za-z0-9:/])\/(?!\/)[^/\s]/u;
+function hasAbsolutePath(value) { return WINDOWS_DRIVE_ABSOLUTE.test(value) || WINDOWS_UNC_ABSOLUTE.test(value) || FILE_URI_ABSOLUTE.test(value) || POSIX_ABSOLUTE.test(value); }
+function redactPathText(value) { return hasAbsolutePath(value) ? '[REDACTED_PATH]' : value; }
+function redactPaths(value) {
+    if (Array.isArray(value))
+        return value.map(redactPaths);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = redactPaths(v);
+        return out;
+    }
+    return typeof value === 'string' ? redactPathText(value) : value;
+}
+function safeEvents(payload, secrets) {
+    const raw = payload?.eventi ?? payload?.events ?? [];
+    if (!Array.isArray(raw))
+        throw coded('SESSION_SHARE_INVALID', 'Session events are invalid.');
+    return raw.filter((event) => event && typeof event === 'object' && !Array.isArray(event) && event.type !== 'ApprovalRequested').map((event) => redactPaths(redactObject(event, secrets)));
+}
+const SESSION_FIELDS = new Set(['id', 'name', 'project', 'model', 'parentId', 'depth', 'delegatedTask', 'forkedFrom', 'startedAt', 'updatedAt', 'endedAt', 'outcome', 'interrupted', 'usage', 'delegationOutcome', 'delegationEvidence', 'tags', 'pinned']);
+function containsAbsolutePath(value) {
+    if (typeof value === 'string')
+        return hasAbsolutePath(value);
+    if (Array.isArray(value))
+        return value.some(containsAbsolutePath);
+    return Boolean(value && typeof value === 'object' && Object.values(value).some(containsAbsolutePath));
+}
+function validateShare(value) {
+    if (!value || value.schema !== SESSION_SHARE_SCHEMA || value.redacted !== true || !value.session || typeof value.session !== 'object' || Array.isArray(value.session) || !Array.isArray(value.events))
+        throw coded('SESSION_SHARE_INVALID');
+    const top = Object.keys(value).sort().join(',');
+    if (top !== 'createdAt,events,redacted,schema,session' || typeof value.createdAt !== 'string' || Number.isNaN(Date.parse(value.createdAt)))
+        throw coded('SESSION_SHARE_INVALID');
+    const session = value.session, keys = Object.keys(session);
+    if (keys.length !== SESSION_FIELDS.size || keys.some(key => !SESSION_FIELDS.has(key)))
+        throw coded('SESSION_SHARE_INVALID');
+    if (typeof session.id !== 'string' || !session.id || !Number.isSafeInteger(session.depth) || session.depth < 0 || typeof session.outcome !== 'string' || !session.outcome || typeof session.interrupted !== 'boolean' || !Array.isArray(session.tags) || session.tags.some((tag) => typeof tag !== 'string') || typeof session.pinned !== 'boolean')
+        throw coded('SESSION_SHARE_INVALID');
+    for (const key of ['name', 'project', 'model', 'parentId', 'delegatedTask', 'forkedFrom', 'startedAt', 'updatedAt', 'endedAt'])
+        if (session[key] !== null && typeof session[key] !== 'string')
+            throw coded('SESSION_SHARE_INVALID');
+    if (value.events.some((event) => !event || typeof event !== 'object' || Array.isArray(event) || event.type === 'ApprovalRequested') || containsAbsolutePath(value))
+        throw coded('SESSION_SHARE_INVALID');
+    return value;
+}
+export function buildSafeSessionShare({ summary, metadata, payload, secrets = [] }) {
+    if (!summary || typeof summary !== 'object')
+        throw coded('SESSION_SHARE_INVALID');
+    const id = textOrNull(summary.id ?? summary.sessionId);
+    if (!id)
+        throw coded('SESSION_SHARE_INVALID');
+    const redactor = createRedactor(secrets);
+    const safeText = (value) => { const text = textOrNull(value); return text === null ? null : redactPathText(redactor.text(text)); };
+    const share = {
+        schema: SESSION_SHARE_SCHEMA, redacted: true, createdAt: new Date().toISOString(),
+        session: {
+            id, name: safeText(summary.name), project: safeText(summary.project), model: safeText(summary.model),
+            parentId: safeText(summary.parentId), depth: Number.isSafeInteger(summary.depth) && summary.depth >= 0 ? summary.depth : 0, delegatedTask: safeText(summary.delegatedTask), forkedFrom: safeText(summary.forkedFrom),
+            startedAt: safeText(summary.startedAt), updatedAt: safeText(summary.updatedAt), endedAt: safeText(summary.endedAt), outcome: safeText(summary.outcome) ?? 'unknown', interrupted: summary.interrupted === true,
+            usage: redactPaths(summary.usage ?? null), delegationOutcome: redactPaths(summary.delegationOutcome ?? null), delegationEvidence: redactPaths(summary.delegationEvidence ?? null),
+            tags: (metadata?.tags ?? []).map(tag => redactPathText(redactor.text(tag))), pinned: metadata?.pinned === true,
+        },
+        events: safeEvents(payload, secrets),
+    };
+    return validateShare(share);
+}
+async function syncDir(dirname) { try {
+    const handle = await open(dirname, 'r');
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+catch (error) {
+    if (process.platform !== 'win32')
+        throw error;
+} }
+export async function writeSafeSessionShare(file, share) {
+    const valid = validateShare(share), body = `${JSON.stringify(valid, null, 2)}\n`;
+    if (Buffer.byteLength(body, 'utf8') > SESSION_SHARE_MAX_BYTES)
+        throw coded('SESSION_SHARE_LIMIT');
+    const dirname = path.dirname(path.resolve(file));
+    await mkdir(dirname, { recursive: true, mode: 0o700 });
+    const target = path.resolve(file), temp = path.join(dirname, `.${path.basename(target)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        const handle = await open(temp, 'wx', 0o600);
+        try {
+            await handle.writeFile(body, 'utf8');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temp, target);
+        try {
+            await chmod(target, 0o600);
+        }
+        catch (error) {
+            if (process.platform !== 'win32')
+                throw error;
+        }
+        await syncDir(dirname);
+    }
+    catch (error) {
+        await rm(temp, { force: true }).catch(() => { });
+        throw error;
+    }
+}

package/dist/sessions/transfer.js

@@ -0,0 +1,16 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+export async function exportCliSession(file, data) { if (data.header.schema !== 'talos.cli.session.v1')
+    throw new Error('SESSION_SCHEMA_UNSUPPORTED'); await mkdir(dirname(file), { recursive: true }); const tmp = `${file}.tmp-${process.pid}`; await writeFile(tmp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 }); await rename(tmp, file); }
+export async function importCliSession(file) { let parsed; try {
+    parsed = JSON.parse(await readFile(file, 'utf8'));
+}
+catch {
+    throw new Error('SESSION_IMPORT_INVALID');
+} if (!parsed || typeof parsed !== 'object')
+    throw new Error('SESSION_IMPORT_INVALID'); const p = parsed; if (p.header?.schema !== 'talos.cli.session.v1')
+    throw new Error('SESSION_SCHEMA_UNSUPPORTED'); if (!Array.isArray(p.events))
+    throw new Error('SESSION_IMPORT_INVALID'); let dropped = 0; const events = p.events.filter(e => { if (e && typeof e === 'object' && e.type === 'ApprovalRequested') {
+    dropped++;
+    return false;
+} return true; }); return { header: p.header, events, pendingApprovalsDropped: dropped }; }

package/dist/subcommands.js

@@ -0,0 +1,62 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { ensureCliPaths, resolveCliPaths } from "./paths.js";
+import { findTalosRepoRoot } from "./runtime/repo.js";
+import { renderSafeTalosFailure } from "./errors.js";
+import { runConfigCommand } from "./commands/config-cli.js";
+import { runProviderCommand, runModelCommand } from "./commands/provider-cli.js";
+import { runSessionCommand } from "./commands/session-cli.js";
+import { runNotesCommand, runTasksCommand, runMemoryCommand, runLibraryCommand, runForgeCommand } from "./commands/services-cli.js";
+import { runMcpCommand, runHookCommand, runPluginCommand, runCustomCommand } from "./commands/extensions-cli.js";
+import { runResearchCommand, runAutomationCommand } from "./commands/advanced-cli.js";
+import { runProjectCommand } from "./commands/project-cli.js";
+import { runCheckpointCommand } from "./commands/checkpoint-cli.js";
+async function defaultRuntimeContext(x) { const { createCliRuntimeContext } = await import("./runtime/create-runtime.js"); return createCliRuntimeContext(x); }
+function emitFailure(io, inv, error) { const failure = renderSafeTalosFailure(inv.outputFormat, error, { component: 'cli', verbose: inv.verbose }); if (failure.toStderr)
+    io.writeErr(failure.text);
+else
+    io.writeOut(failure.text); return failure.exitCode; }
+export async function runSubcommand(inv, deps) {
+    const io = deps.io;
+    const [family, ...args] = inv.positionals;
+    if (!family)
+        return emitFailure(io, inv, Object.assign(new Error('Subcommand required'), { code: 'CLI_USAGE_ERROR' }));
+    try {
+        const projectRoot = resolve(inv.project ?? process.cwd());
+        const paths = deps.paths ?? resolveCliPaths(process.env, process.platform, homedir());
+        await ensureCliPaths(paths);
+        const repoRoot = deps.repoRoot ?? findTalosRepoRoot(process.cwd());
+        const ctx = { invocation: inv, io, projectRoot, paths, repoRoot, createRuntimeContext: deps.createRuntimeContext ?? defaultRuntimeContext };
+        switch (family) {
+            case 'project': return await runProjectCommand(ctx, args);
+            case 'config': return await runConfigCommand(ctx, args);
+            case 'provider': return await runProviderCommand(ctx, args);
+            case 'model': return await runModelCommand(ctx, args);
+            case 'session': return await runSessionCommand(ctx, args);
+            case 'mcp': return await runMcpCommand(ctx, args);
+            case 'hook': return await runHookCommand(ctx, args);
+            case 'plugin': return await runPluginCommand(ctx, args);
+            case 'command': return await runCustomCommand(ctx, args);
+            case 'memory': return await runMemoryCommand(ctx, args);
+            case 'notes': return await runNotesCommand(ctx, args);
+            case 'tasks': return await runTasksCommand(ctx, args);
+            case 'library': return await runLibraryCommand(ctx, args);
+            case 'research': return await runResearchCommand(ctx, args);
+            case 'automation': return await runAutomationCommand(ctx, args);
+            case 'forge': return await runForgeCommand(ctx, args);
+            case 'checkpoint': return await runCheckpointCommand(ctx, args);
+            case 'doctor':
+            case 'logs':
+            case 'diagnostic':
+            case 'update':
+            case 'init': {
+                const { runSystemCommand } = await import("./commands/system-cli.js");
+                return await runSystemCommand(ctx, family, args);
+            }
+            default: throw new Error(`Unsupported subcommand: ${family}`);
+        }
+    }
+    catch (error) {
+        return emitFailure(io, inv, error);
+    }
+}

package/dist/tui/agent-roster.js

@@ -0,0 +1,36 @@
+function rowOf(node, level, focusId) {
+    const collisionCount = node.collisions.length;
+    return {
+        id: node.id,
+        parentId: node.parentId,
+        level,
+        nativeDepth: node.nativeDepth,
+        role: node.nativeDepth === 0 && node.parentId === null ? 'main' : 'subagent',
+        focused: node.id === focusId,
+        name: node.name,
+        task: node.task,
+        model: node.model,
+        outcome: node.outcome,
+        interrupted: node.interrupted,
+        startedAt: node.startedAt,
+        updatedAt: node.updatedAt,
+        endedAt: node.endedAt,
+        usage: node.usage ? { ...node.usage } : null,
+        collisionCount,
+        hasCollision: collisionCount > 0,
+        delegationOutcome: node.delegationOutcome,
+        delegationEvidence: node.delegationEvidence ? { ...node.delegationEvidence } : null,
+    };
+}
+export function agentRosterRows(tree) {
+    if (!tree)
+        return [];
+    const rows = [];
+    const visit = (node, level) => {
+        rows.push(rowOf(node, level, tree.focusId));
+        for (const child of node.children)
+            visit(child, level + 1);
+    };
+    visit(tree.root, 0);
+    return rows;
+}