@quadient/skillshare 1.8.1 → 1.10.0

package/dist/agents-detect.js

@@ -0,0 +1,147 @@
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, isAbsolute, join, resolve } from 'node:path';
+/** Model aliases Claude Code resolves to the latest release; Claude Code itself has no command that lists models. */
+export const CLAUDE_MODELS = ['fable', 'opus', 'sonnet', 'haiku'];
+export const CLAUDE_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,99}$/;
+export function profilesPath(home = homedir()) {
+    return process.platform === 'win32'
+        ? join(process.env.APPDATA ?? join(home, 'AppData', 'Roaming'), 'skillshare', 'agents.json')
+        : join(home, '.config', 'skillshare', 'agents.json');
+}
+export async function detectAgents(options = {}) {
+    const home = options.home ?? homedir();
+    const env = options.env ?? process.env;
+    const version = options.version ?? commandVersion;
+    const read = options.read ?? readOptional;
+    const agents = [];
+    const problems = [];
+    const claudeVersion = await version('claude');
+    if (claudeVersion !== null) {
+        const settings = parseJson(await read(join(env.CLAUDE_CONFIG_DIR ?? join(home, '.claude'), 'settings.json')));
+        const configured = Array.isArray(settings?.availableModels) ? settings.availableModels.filter((m) => typeof m === 'string') : [];
+        const models = [...new Set([...CLAUDE_MODELS, ...configured])].filter(id => NAME.test(id) && id !== 'default')
+            .map(id => ({ id, reasoningLevels: CLAUDE_EFFORT_LEVELS }));
+        agents.push({ kind: 'claude', version: parseVersion(claudeVersion), models, warnings: [] });
+    }
+    const codexVersion = await version('codex');
+    if (codexVersion !== null) {
+        const codexHome = env.CODEX_HOME ?? join(home, '.codex');
+        const warnings = [];
+        const cache = parseJson(await read(join(codexHome, 'models_cache.json')));
+        const models = Array.isArray(cache?.models) ? cache.models
+            .filter((m) => m?.visibility === 'list' && typeof m.slug === 'string' && NAME.test(m.slug))
+            .map((m) => {
+            const levels = (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : [])
+                .map((level) => typeof level === 'string' ? level : level?.effort)
+                .filter((level) => typeof level === 'string' && NAME.test(level) && level !== 'default');
+            const fallback = typeof m.default_reasoning_level === 'string' && levels.includes(m.default_reasoning_level) ? m.default_reasoning_level : undefined;
+            return { id: m.slug, displayName: typeof m.display_name === 'string' ? m.display_name.slice(0, 100) : undefined,
+                reasoningLevels: levels.slice(0, 16), defaultReasoning: fallback };
+        }).slice(0, 64) : [];
+        if (models.length === 0)
+            warnings.push('No Codex model list found in models_cache.json. Run codex once to refresh it; only the default model is offered.');
+        const configured = defaultCodexModel(await read(join(codexHome, 'config.toml')));
+        if (configured && models.length > 0 && !models.some(m => m.id === configured))
+            warnings.push(`The default model "${configured}" from config.toml is not in the Codex model list and may be rejected; pick a model explicitly.`);
+        agents.push({ kind: 'codex', version: parseVersion(codexVersion), models, warnings });
+    }
+    const profiles = parseProfiles(await read(profilesPath(home)), home, problems);
+    for (const profile of profiles)
+        if (!agents.some(agent => agent.kind === profile.agent))
+            problems.push(`Profile "${profile.name}" uses ${profile.agent}, which is not installed.`);
+    return {
+        capabilities: { agents, profiles: profiles.map(p => ({ name: p.name, agent: p.agent, model: p.model, reasoning: p.reasoning,
+                workdir: p.workdir ? basename(p.workdir) : undefined, ...(p.sandbox ? { sandbox: true } : {}) })) },
+        profiles,
+        problems,
+    };
+}
+export function parseProfiles(text, home, problems = []) {
+    if (text === null)
+        return [];
+    const parsed = parseJson(text);
+    if (!Array.isArray(parsed?.profiles)) {
+        problems.push(`${profilesPath(home)} must contain { "profiles": [...] }.`);
+        return [];
+    }
+    const profiles = [];
+    for (const raw of parsed.profiles) {
+        const name = raw?.name;
+        if (typeof name !== 'string' || !NAME.test(name)) {
+            problems.push('Skipped a profile without a valid name.');
+            continue;
+        }
+        if (raw.agent !== 'claude' && raw.agent !== 'codex') {
+            problems.push(`Profile "${name}" needs "agent": "claude" or "codex".`);
+            continue;
+        }
+        if (profiles.some(p => p.name === name)) {
+            problems.push(`Profile "${name}" is declared twice.`);
+            continue;
+        }
+        const optional = (key) => typeof raw[key] === 'string' && NAME.test(raw[key]) ? raw[key] : undefined;
+        if (raw.model !== undefined && !optional('model') || raw.reasoning !== undefined && !optional('reasoning')) {
+            problems.push(`Profile "${name}" has an invalid model or reasoning.`);
+            continue;
+        }
+        if (raw.sandbox !== undefined && typeof raw.sandbox !== 'boolean') {
+            problems.push(`Profile "${name}" sandbox must be true or false.`);
+            continue;
+        }
+        if (raw.args !== undefined && (!Array.isArray(raw.args) || raw.args.some(arg => typeof arg !== 'string'))) {
+            problems.push(`Profile "${name}" args must be a list of strings.`);
+            continue;
+        }
+        profiles.push({ name, agent: raw.agent, model: optional('model'), reasoning: optional('reasoning'),
+            workdir: typeof raw.workdir === 'string' && raw.workdir.length > 0 ? expandHome(raw.workdir, home) : undefined,
+            args: raw.args ?? [], ...(raw.sandbox === true ? { sandbox: true } : {}) });
+    }
+    return profiles.slice(0, 32);
+}
+export function expandHome(path, home = homedir()) {
+    const expanded = path === '~' ? home : path.startsWith('~/') ? join(home, path.slice(2)) : path;
+    return isAbsolute(expanded) ? expanded : resolve(expanded);
+}
+/** Reads the top-level model key only; profiles and providers further down the file are ignored. */
+export function defaultCodexModel(toml) {
+    if (!toml)
+        return undefined;
+    for (const line of toml.split(/\r?\n/)) {
+        if (/^\s*\[/.test(line))
+            return undefined;
+        const match = /^\s*model\s*=\s*"([^"]+)"/.exec(line);
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
+function parseVersion(output) {
+    return (/\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?/.exec(output)?.[0] ?? output.trim()).slice(0, 100) || undefined;
+}
+function parseJson(text) {
+    if (text === null)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === 'object' ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function readOptional(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function commandVersion(command) {
+    return new Promise(resolvePromise => {
+        execFile(command, ['--version'], { timeout: 15_000, windowsHide: true, shell: process.platform === 'win32' }, (error, stdout) => resolvePromise(error ? null : stdout.toString()));
+    });
+}

package/dist/agents-process.js

@@ -0,0 +1,50 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+/**
+ * Starts an agent that speaks newline-delimited JSON on stdio. Tokens go through the environment only. A separate
+ * process group lets stopping the agent also stop the shell commands it runs.
+ */
+export function startAgentProcess(options) {
+    const posix = process.platform !== 'win32';
+    const child = (options.spawnAgent ?? spawn)(options.command, options.args, {
+        cwd: options.cwd, env: { ...process.env, ...options.env }, stdio: ['pipe', 'pipe', 'pipe'],
+        detached: posix, windowsHide: true, shell: !posix,
+    });
+    let stderr = '';
+    child.stderr?.on('data', chunk => { stderr = (stderr + chunk).slice(-4000); });
+    child.stdin?.on('error', () => { });
+    if (child.stdout)
+        createInterface({ input: child.stdout, crlfDelay: Infinity }).on('line', line => { if (line.trim())
+            options.onLine(line); });
+    const exited = new Promise(resolve => {
+        child.once('error', error => { stderr = (stderr + '\n' + error.message).slice(-4000); resolve(null); });
+        child.once('exit', code => resolve(code));
+    });
+    let killing = null;
+    return {
+        child,
+        exited,
+        stderrTail: () => stderr.trim().split(/\r?\n/).filter(line => line.trim()).slice(-3).join(' ').slice(-300),
+        write: line => child.stdin?.writable ? child.stdin.write(line + '\n') : false,
+        kill() {
+            killing ??= (async () => {
+                const signal = (sig) => {
+                    try {
+                        if (posix && child.pid)
+                            process.kill(-child.pid, sig);
+                        else
+                            child.kill(sig);
+                    }
+                    catch { }
+                };
+                child.stdin?.end();
+                signal('SIGTERM');
+                const timer = setTimeout(() => signal('SIGKILL'), 5000);
+                timer.unref?.();
+                await exited;
+                clearTimeout(timer);
+            })();
+            return killing;
+        },
+    };
+}

package/dist/agents-session.js

@@ -0,0 +1,267 @@
+import { setTimeout as delay } from 'node:timers/promises';
+/** Read-only tools Claude Code may use in a sandboxed session; the session's MCP servers are added per server. */
+export const CLAUDE_SANDBOX_TOOLS = ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
+export const SANDBOX_NOTE = 'This session is sandboxed: you can read files, search and use the provided MCP tools, but you cannot change files or ' +
+    'run commands that modify anything.';
+export const DEFAULT = 'default';
+const MAX_TEXT = 50_000;
+export function isSandboxed(configuration, options) {
+    return options.sandbox === true || options.profile?.sandbox === true || configuration.sandbox === true;
+}
+/** MCP server names become tool prefixes and config keys, so they are reduced to a safe alphabet. */
+export function mcpServerName(server, index) {
+    return server.name.replace(/[^A-Za-z0-9_-]/g, '_') || `server_${index}`;
+}
+/** Tokens go to environment variables only, so they never appear in a command line or a protocol frame. */
+export function mcpTokenEnvironment(servers) {
+    return Object.fromEntries(servers.map((server, index) => [`SKILLSHARE_MCP_TOKEN_${index}`, server.bearerToken]));
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function clip(text, length = MAX_TEXT) {
+    return text.length <= length ? text : text.slice(0, length) + '…';
+}
+export function oneLine(text, length = 300) {
+    return clip(text.replace(/\s+/g, ' ').trim(), length);
+}
+/**
+ * Batches a session's events for upload. Updates of the same transcript entry are merged, so a fast stream of text
+ * deltas costs one request per flush, and a slow connection never queues more than one copy of each entry.
+ */
+export class EventQueue {
+    upload;
+    intervalMs;
+    onGone;
+    queue = [];
+    flushing = null;
+    timer = null;
+    gone = false;
+    constructor(upload, intervalMs = 1000, onGone = () => { }) {
+        this.upload = upload;
+        this.intervalMs = intervalMs;
+        this.onGone = onGone;
+    }
+    push(event) {
+        if (this.gone)
+            return;
+        if (event.type === 'item') {
+            const index = this.queue.findIndex(e => e.type === 'item' && e.key === event.key);
+            if (index >= 0) {
+                // Only the latest state of an entry matters; keep its place so the transcript order stays stable.
+                this.queue[index] = { ...this.queue[index], ...event };
+                this.schedule();
+                return;
+            }
+        }
+        this.queue.push(event);
+        if (event.type === 'item')
+            this.schedule();
+        else
+            void this.flush();
+    }
+    schedule() {
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => { this.timer = null; void this.flush(); }, this.intervalMs);
+    }
+    /** Sends everything queued so far, retrying with backoff until it is accepted or the server rejects the session. */
+    flush() {
+        if (this.flushing)
+            return this.flushing.then(() => this.queue.length > 0 ? this.flush() : undefined);
+        this.flushing = (async () => {
+            let failures = 0;
+            while (this.queue.length > 0 && !this.gone) {
+                const batch = this.queue.slice(0, 200);
+                const result = await this.upload(batch).catch(() => 'retry');
+                if (result === 'gone') {
+                    this.gone = true;
+                    this.queue = [];
+                    this.onGone();
+                    break;
+                }
+                if (result === 'retry') {
+                    await delay(Math.min(30_000, 1000 * 2 ** Math.min(failures++, 5)));
+                    continue;
+                }
+                failures = 0;
+                this.queue.splice(0, batch.length);
+            }
+        })().finally(() => { this.flushing = null; });
+        return this.flushing;
+    }
+}
+/**
+ * Runs one session on this computer: starts the agent, feeds it the user's messages one turn at a time, enforces the turn
+ * timeout, closes the agent after a quiet period and reports everything as SessionEvents. The server decides what happens
+ * next; the runner only reports and obeys.
+ */
+export class SessionRunner {
+    options;
+    sessionId;
+    leaseToken;
+    events;
+    driver;
+    seen = new Set();
+    pending = [];
+    now;
+    opened = null;
+    openSucceeded = false;
+    turnRunning = false;
+    interruptRequested = false;
+    idleTimer = null;
+    closing = null;
+    closedReported = false;
+    done;
+    resolveDone;
+    constructor(options) {
+        this.options = options;
+        this.sessionId = options.sessionId;
+        this.leaseToken = options.leaseToken;
+        this.now = options.now ?? Date.now;
+        this.done = new Promise(resolve => { this.resolveDone = resolve; });
+        // A rejected lease means the server moved on; the agent must stop without reporting anything more.
+        this.events = new EventQueue(options.upload, options.flushIntervalMs, () => void this.stop());
+        this.driver = options.driver({
+            sessionId: options.sessionId,
+            start: options.start,
+            workdir: options.workdir,
+            profile: options.profile,
+            sandbox: options.sandbox,
+            item: item => this.events.push({ type: 'item', ...item, text: item.text === undefined ? undefined : clip(item.text) }),
+            thread: threadId => this.events.push({ type: 'thread', threadId }),
+            exited: error => void this.finish(error ?? 'The agent stopped unexpectedly.'),
+        });
+    }
+    get stopping() { return this.closing !== null; }
+    /** Queues messages for the next turns; the server may send a message again, so repeats are ignored. */
+    send(messages) {
+        for (const message of messages) {
+            if (this.seen.has(message.id))
+                continue;
+            this.seen.add(message.id);
+            this.pending.push(message);
+        }
+        void this.pump();
+    }
+    async interrupt() {
+        if (!this.turnRunning || this.interruptRequested)
+            return;
+        this.interruptRequested = true;
+        await this.driver.interrupt().catch(() => { });
+    }
+    /** Stops the agent and reports the session as closed, so the server can resume it later or finish ending it. */
+    close(error) {
+        return this.finish(error);
+    }
+    /** Stops the agent without reporting, because the server no longer accepts this lease. */
+    stop() {
+        this.closedReported = true;
+        return this.finish();
+    }
+    async pump() {
+        if (this.turnRunning || this.closing)
+            return;
+        const message = this.pending.shift();
+        if (!message) {
+            this.armIdle();
+            return;
+        }
+        this.clearIdle();
+        this.turnRunning = true;
+        this.interruptRequested = false;
+        const started = this.now();
+        if (!this.openSucceeded) {
+            try {
+                this.opened ??= this.driver.open();
+                await this.opened;
+                this.openSucceeded = true;
+            }
+            catch (error) {
+                const reason = errorMessage(error);
+                // A failed resume uses up the message as a failed turn, so the server does not ask for the same start again.
+                // A first start that fails has nothing to resume; the server fails the whole session.
+                if (this.options.start.resumeThreadId) {
+                    this.events.push({ type: 'turnStarted', messageId: message.id });
+                    this.events.push({ type: 'turnCompleted', status: 'failed', error: reason });
+                }
+                this.turnRunning = false;
+                await this.finish(reason);
+                return;
+            }
+        }
+        if (this.closing)
+            return;
+        this.events.push({ type: 'turnStarted', messageId: message.id });
+        let outcome;
+        try {
+            outcome = await this.withTimeout(this.driver.turn(message));
+        }
+        catch (error) {
+            outcome = { status: 'failed', error: errorMessage(error) };
+        }
+        if (this.closing)
+            return;
+        if (this.interruptRequested && outcome.status === 'failed' && !outcome.error)
+            outcome = { ...outcome, status: 'interrupted' };
+        this.events.push({ type: 'turnCompleted', status: outcome.status, error: outcome.error,
+            stats: { ...outcome.stats, durationMs: this.now() - started } });
+        this.turnRunning = false;
+        void this.events.flush();
+        void this.pump();
+    }
+    /** Interrupts a turn that runs past its timeout, and gives up on an agent that does not stop when asked. */
+    async withTimeout(turn) {
+        const timeoutMs = Math.max(1, this.options.start.turnTimeoutSeconds) * 1000;
+        let timer;
+        let expired = false;
+        const timedOut = new Promise(resolve => {
+            timer = setTimeout(async () => {
+                expired = true;
+                await this.interrupt();
+                const stopped = await Promise.race([turn.then(() => true), delay(15_000).then(() => false)]);
+                resolve(stopped ? { status: 'interrupted', error: `The turn did not finish within ${this.options.start.turnTimeoutSeconds} seconds.` }
+                    : { status: 'failed', error: `The agent did not stop after ${this.options.start.turnTimeoutSeconds} seconds.` });
+                if (!stopped)
+                    void this.finish(`The agent did not stop after ${this.options.start.turnTimeoutSeconds} seconds.`);
+            }, timeoutMs);
+        });
+        try {
+            const outcome = await Promise.race([turn, timedOut]);
+            // The interrupt usually ends the turn before the timeout path does; the outcome should still say why it stopped.
+            return expired && outcome.status !== 'completed' && !outcome.error
+                ? { ...outcome, error: `The turn did not finish within ${this.options.start.turnTimeoutSeconds} seconds.` } : outcome;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    armIdle() {
+        this.clearIdle();
+        if (this.closing)
+            return;
+        this.idleTimer = setTimeout(() => void this.close(), this.options.idleMs ?? 15 * 60_000);
+    }
+    clearIdle() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+    }
+    finish(error) {
+        this.closing ??= (async () => {
+            this.clearIdle();
+            await this.driver.close().catch(() => { });
+            if (this.turnRunning && !this.closedReported) {
+                this.events.push({ type: 'turnCompleted', status: 'failed', error: error ?? 'The agent was stopped.' });
+                this.turnRunning = false;
+            }
+            if (!this.closedReported) {
+                this.closedReported = true;
+                this.events.push({ type: 'closed', error });
+            }
+            await this.events.flush();
+            this.resolveDone();
+        })();
+        return this.closing;
+    }
+}