terminal-pilot 0.0.19 → 0.0.21

package/node_modules/@poe-code/agent-skill-config/dist/configs.js

@@ -0,0 +1,70 @@
+import os from "node:os";
+import path from "node:path";
+import { resolveAgentId } from "@poe-code/agent-defs";
+const agentSkillConfigs = {
+    "claude-code": {
+        globalSkillDir: "~/.claude/skills",
+        localSkillDir: ".claude/skills"
+    },
+    codex: {
+        globalSkillDir: "~/.codex/skills",
+        localSkillDir: ".codex/skills"
+    },
+    "gemini-cli": {
+        globalSkillDir: "~/.gemini/skills",
+        localSkillDir: ".gemini/skills"
+    },
+    opencode: {
+        globalSkillDir: "~/.config/opencode/skills",
+        localSkillDir: ".opencode/skills"
+    },
+    goose: {
+        globalSkillDir: "~/.agents/skills",
+        localSkillDir: ".agents/skills"
+    }
+};
+export const supportedAgents = Object.freeze(Object.keys(agentSkillConfigs));
+export function resolveAgentSupport(input, registry = agentSkillConfigs) {
+    const resolvedId = resolveAgentId(input);
+    if (!resolvedId) {
+        return { status: "unknown", input };
+    }
+    const config = registry[resolvedId];
+    if (!config) {
+        return { status: "unsupported", input, id: resolvedId };
+    }
+    return { status: "supported", input, id: resolvedId, config: { ...config } };
+}
+export function getAgentConfig(agentId) {
+    const support = resolveAgentSupport(agentId);
+    return support.status === "supported" ? support.config : undefined;
+}
+function expandHome(targetPath, homeDir = os.homedir()) {
+    if (!targetPath?.startsWith("~")) {
+        return targetPath;
+    }
+    if (targetPath === "~") {
+        return homeDir;
+    }
+    // Handle ~./ -> ~/.
+    if (targetPath.startsWith("~./")) {
+        targetPath = `~/.${targetPath.slice(3)}`;
+    }
+    let remainder = targetPath.slice(1);
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+        remainder = remainder.slice(1);
+    }
+    else if (remainder.startsWith(".")) {
+        remainder = remainder.slice(1);
+        if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+            remainder = remainder.slice(1);
+        }
+    }
+    return remainder.length === 0 ? homeDir : path.join(homeDir, remainder);
+}
+export function resolveSkillDir(config, scope, cwd, homeDir) {
+    if (scope === "global") {
+        return path.resolve(expandHome(config.globalSkillDir, homeDir));
+    }
+    return path.resolve(cwd, config.localSkillDir);
+}

package/node_modules/@poe-code/agent-skill-config/dist/exports.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@poe-code/agent-skill-config/dist/exports.compile-check.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@poe-code/agent-skill-config/dist/git-exclude.d.ts

@@ -0,0 +1,8 @@
+export type GitDirRunner = (cwd: string) => string | undefined;
+export declare function setGitDirRunnerForTest(runner: GitDirRunner): () => void;
+export declare function appendExcludeBlock(cwd: string, runId: string, entries: string[], opts?: {
+    markerPrefix?: string;
+}): string | undefined;
+export declare function removeExcludeBlock(cwd: string, runId: string, opts?: {
+    markerPrefix?: string;
+}): void;

package/node_modules/@poe-code/agent-skill-config/dist/git-exclude.js

@@ -0,0 +1,159 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import path from "node:path";
+const defaultMarkerPrefix = "poe-code-spawn-skills";
+function defaultGitDirRunner(cwd) {
+    try {
+        return execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"]
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+let gitDirRunner = defaultGitDirRunner;
+let tempFileCounter = 0;
+export function setGitDirRunnerForTest(runner) {
+    const previous = gitDirRunner;
+    gitDirRunner = runner;
+    return () => {
+        gitDirRunner = previous;
+    };
+}
+function resolveExcludePath(cwd) {
+    const gitDir = gitDirRunner(cwd);
+    if (gitDir === undefined || gitDir.length === 0) {
+        return undefined;
+    }
+    return path.join(path.isAbsolute(gitDir) ? gitDir : path.resolve(cwd, gitDir), "info/exclude");
+}
+function markers(runId, markerPrefix) {
+    return {
+        begin: `# ${markerPrefix}:${runId} begin`,
+        end: `# ${markerPrefix}:${runId} end`
+    };
+}
+function assertSingleLine(value, label) {
+    if (value.includes("\n") || value.includes("\r")) {
+        throw new Error(`${label} must be a single line`);
+    }
+}
+function readExcludeFile(excludePath) {
+    try {
+        return fs.readFileSync(excludePath, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function assertNoSymbolicLink(targetPath) {
+    const parsed = path.parse(path.resolve(targetPath));
+    let current = parsed.root;
+    for (const segment of path.resolve(targetPath).slice(parsed.root.length).split(path.sep)) {
+        if (segment.length === 0) {
+            continue;
+        }
+        current = path.join(current, segment);
+        try {
+            if (fs.lstatSync(current).isSymbolicLink()) {
+                throw new Error(`Refusing to update Git exclude path through symbolic link: ${current}`);
+            }
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+    }
+}
+function writeExcludeFile(excludePath, content) {
+    assertNoSymbolicLink(excludePath);
+    fs.mkdirSync(path.dirname(excludePath), { recursive: true });
+    assertNoSymbolicLink(excludePath);
+    const tempPath = `${excludePath}.poe-code-${process.pid}-${tempFileCounter++}.tmp`;
+    try {
+        fs.writeFileSync(tempPath, content, "utf8");
+        fs.renameSync(tempPath, excludePath);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(tempPath, { force: true });
+        }
+        catch (cleanupError) {
+            void cleanupError;
+        }
+        throw error;
+    }
+}
+function removeBlock(content, runId, markerPrefix) {
+    const { begin, end } = markers(runId, markerPrefix);
+    const lines = content.split("\n");
+    const result = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        if (lines[index] === begin) {
+            const endIndex = lines.indexOf(end, index + 1);
+            if (endIndex !== -1) {
+                index = endIndex;
+                continue;
+            }
+        }
+        result.push(lines[index]);
+    }
+    return result.join("\n");
+}
+function appendBlock(content, runId, entries, markerPrefix) {
+    const { begin, end } = markers(runId, markerPrefix);
+    const existing = content ?? "";
+    const prefix = existing.length === 0 || existing.endsWith("\n") ? existing : `${existing}\n`;
+    return `${prefix}${[begin, ...entries, end, ""].join("\n")}`;
+}
+function nextBlockId(content, runId, markerPrefix) {
+    if (content === undefined || !content.includes(markers(runId, markerPrefix).begin)) {
+        return runId;
+    }
+    let suffix = 1;
+    while (content.includes(markers(`${runId}:${suffix}`, markerPrefix).begin)) {
+        suffix += 1;
+    }
+    return `${runId}:${suffix}`;
+}
+export function appendExcludeBlock(cwd, runId, entries, opts) {
+    assertSingleLine(runId, "runId");
+    assertSingleLine(opts?.markerPrefix ?? defaultMarkerPrefix, "markerPrefix");
+    for (const entry of entries) {
+        assertSingleLine(entry, "exclude entry");
+    }
+    const excludePath = resolveExcludePath(cwd);
+    if (excludePath === undefined) {
+        return undefined;
+    }
+    assertNoSymbolicLink(excludePath);
+    const content = readExcludeFile(excludePath);
+    const markerPrefix = opts?.markerPrefix ?? defaultMarkerPrefix;
+    const blockId = nextBlockId(content, runId, markerPrefix);
+    writeExcludeFile(excludePath, appendBlock(content, blockId, entries, markerPrefix));
+    return blockId;
+}
+export function removeExcludeBlock(cwd, runId, opts) {
+    assertSingleLine(runId, "runId");
+    assertSingleLine(opts?.markerPrefix ?? defaultMarkerPrefix, "markerPrefix");
+    const excludePath = resolveExcludePath(cwd);
+    if (excludePath === undefined) {
+        return;
+    }
+    const content = readExcludeFile(excludePath);
+    if (content === undefined) {
+        return;
+    }
+    writeExcludeFile(excludePath, removeBlock(content, runId, opts?.markerPrefix ?? defaultMarkerPrefix));
+}

package/node_modules/@poe-code/agent-skill-config/dist/index.d.ts

@@ -0,0 +1,11 @@
+export type { AgentSkillConfig, AgentSupportResult, AgentSupportStatus, SkillScope } from "./configs.js";
+export type { ApplyOptions, SkillFile } from "./types.js";
+export type { SkillResolution, SkillResolutionFailure, SkillSource } from "./resolve-skill-reference.js";
+export type { BridgeEntry, BridgeManifest, BridgeWarning, BridgeWarningKind } from "./bridge-active-skills.js";
+export { supportedAgents, resolveAgentSupport, getAgentConfig, resolveSkillDir } from "./configs.js";
+export { configure, unconfigure, installSkill, UnsupportedAgentError } from "./apply.js";
+export type { InstallSkillOptions, InstallSkillResult } from "./apply.js";
+export { resolveSkillReference } from "./resolve-skill-reference.js";
+export { appendExcludeBlock, removeExcludeBlock } from "./git-exclude.js";
+export { setGitDirRunnerForTest } from "./git-exclude.js";
+export { bridgeActiveSkills, cleanupBridgedSkills } from "./bridge-active-skills.js";

package/node_modules/@poe-code/agent-skill-config/dist/index.js

@@ -0,0 +1,6 @@
+export { supportedAgents, resolveAgentSupport, getAgentConfig, resolveSkillDir } from "./configs.js";
+export { configure, unconfigure, installSkill, UnsupportedAgentError } from "./apply.js";
+export { resolveSkillReference } from "./resolve-skill-reference.js";
+export { appendExcludeBlock, removeExcludeBlock } from "./git-exclude.js";
+export { setGitDirRunnerForTest } from "./git-exclude.js";
+export { bridgeActiveSkills, cleanupBridgedSkills } from "./bridge-active-skills.js";

package/node_modules/@poe-code/agent-skill-config/dist/resolve-skill-reference.d.ts

@@ -0,0 +1,22 @@
+export interface SkillSource {
+    kind: "resolved";
+    ref: string;
+    name: string;
+    sourceAgentId?: string;
+    sourcePath: string;
+    scope: "project" | "user";
+}
+export type SkillResolutionFailure = {
+    kind: "malformed";
+    ref: string;
+} | {
+    kind: "unknown-agent";
+    ref: string;
+    agentInput: string;
+} | {
+    kind: "not-found";
+    ref: string;
+    searchedPaths: string[];
+};
+export type SkillResolution = SkillSource | SkillResolutionFailure;
+export declare function resolveSkillReference(ref: string, cwd: string, homeDir: string): SkillResolution;

package/node_modules/@poe-code/agent-skill-config/dist/resolve-skill-reference.js

@@ -0,0 +1,87 @@
+import { statSync } from "node:fs";
+import path from "node:path";
+import { getAgentConfig, resolveAgentSupport, resolveSkillDir } from "./configs.js";
+function isMalformedSegment(segment) {
+    return (segment.length === 0 ||
+        segment !== segment.trim() ||
+        segment === "." ||
+        segment === ".." ||
+        segment.includes("\n") ||
+        segment.includes("\r"));
+}
+function isDirectory(targetPath) {
+    try {
+        return statSync(targetPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function findSkill(ref, name, tiers, sourceAgentId) {
+    for (const tier of tiers) {
+        if (isDirectory(tier.sourcePath)) {
+            return {
+                kind: "resolved",
+                ref,
+                name,
+                ...(sourceAgentId ? { sourceAgentId } : {}),
+                sourcePath: tier.sourcePath,
+                scope: tier.scope
+            };
+        }
+    }
+    return {
+        kind: "not-found",
+        ref,
+        searchedPaths: tiers.map((tier) => tier.sourcePath)
+    };
+}
+export function resolveSkillReference(ref, cwd, homeDir) {
+    const slashIndex = ref.indexOf("/");
+    const hasPrefix = slashIndex !== -1;
+    if (ref.length === 0 ||
+        ref !== ref.trim() ||
+        (hasPrefix && ref.indexOf("/", slashIndex + 1) !== -1)) {
+        return { kind: "malformed", ref };
+    }
+    if (!hasPrefix) {
+        if (isMalformedSegment(ref)) {
+            return { kind: "malformed", ref };
+        }
+        const tiers = [
+            {
+                scope: "project",
+                sourcePath: path.resolve(cwd, ".poe-code/skills", ref)
+            },
+            {
+                scope: "user",
+                sourcePath: path.resolve(homeDir, ".poe-code/skills", ref)
+            }
+        ];
+        return findSkill(ref, ref, tiers);
+    }
+    const agentInput = ref.slice(0, slashIndex);
+    const name = ref.slice(slashIndex + 1);
+    if (isMalformedSegment(agentInput) || isMalformedSegment(name)) {
+        return { kind: "malformed", ref };
+    }
+    const support = resolveAgentSupport(agentInput);
+    if (support.status !== "supported" || !support.id) {
+        return { kind: "unknown-agent", ref, agentInput };
+    }
+    const config = getAgentConfig(support.id);
+    if (!config) {
+        return { kind: "unknown-agent", ref, agentInput };
+    }
+    const tiers = [
+        {
+            scope: "project",
+            sourcePath: path.resolve(resolveSkillDir(config, "local", cwd), name)
+        },
+        {
+            scope: "user",
+            sourcePath: path.resolve(resolveSkillDir(config, "global", cwd, homeDir), name)
+        }
+    ];
+    return findSkill(ref, name, tiers, support.id);
+}

package/node_modules/@poe-code/agent-skill-config/dist/templates/poe-generate.md

@@ -0,0 +1,47 @@
+---
+name: poe-generate
+description: 'Poe code generation skill'
+---
+
+# poe-code generate
+
+Use `poe-code generate` to create text, images, audio, or video via the Poe API.
+
+## Text generation
+
+```bash
+poe-code generate "Write a short function that parses a JSON string safely."
+```
+
+Specify the model/bot:
+
+```bash
+# CLI option
+poe-code generate --model "gpt-4.1" "Summarize this codebase change."
+
+# Some agent runtimes call the model selector `--bot`
+poe-code generate --bot "gpt-4.1" "Summarize this codebase change."
+```
+
+## Media generation
+
+The CLI supports media generation as subcommands:
+
+```bash
+poe-code generate image "A 3D render of a rubber duck wearing sunglasses" --model "gpt-image-1" -o duck.png
+poe-code generate video "A cinematic timelapse of a city at night" --model "veo" -o city.mp4
+poe-code generate audio "A calm 10 second lo-fi beat" --model "audio-model" -o beat.wav
+```
+
+Some agent runtimes expose the same media types as flags. If available, these are equivalent:
+
+```bash
+poe-code generate --image "A 3D render of a rubber duck wearing sunglasses" --bot "gpt-image-1" -o duck.png
+poe-code generate --video "A cinematic timelapse of a city at night" --bot "veo" -o city.mp4
+poe-code generate --audio "A calm 10 second lo-fi beat" --bot "audio-model" -o beat.wav
+```
+
+## Tips
+
+- Use `--param key=value` to pass provider/model parameters (repeatable).
+- Use `--output <path>` (or `-o`) for media outputs.

package/node_modules/@poe-code/agent-skill-config/dist/templates/terminal-pilot.md

@@ -0,0 +1,45 @@
+---
+name: terminal-pilot
+description: 'Terminal automation skill using the terminal-pilot CLI'
+---
+
+# Terminal Pilot
+
+Use the `terminal-pilot` CLI when you need to automate or inspect interactive
+CLI applications through a real PTY session.
+
+## Commands
+
+- `terminal-pilot create-session` - start a PTY-backed command
+- `terminal-pilot fill` - paste text into a session
+- `terminal-pilot type` - type character-by-character for TUIs and readline
+- `terminal-pilot press-key` - send named keys such as `Enter` or `ArrowDown`
+- `terminal-pilot wait-for` - wait for terminal output to match a pattern
+- `terminal-pilot wait-for-exit` - block until a session exits
+- `terminal-pilot read-screen` - inspect the current visible terminal screen
+- `terminal-pilot read-history` - read scrollback output
+- `terminal-pilot list-sessions` - list active sessions
+- `terminal-pilot close-session` - close a session and return its exit code
+
+## Examples
+
+```bash
+terminal-pilot --help
+terminal-pilot create-session --help
+terminal-pilot read-screen --help
+```
+
+Use JSON output when another tool or script needs to read the result:
+
+```bash
+terminal-pilot list-sessions --output json
+terminal-pilot read-screen --session s1 --output json
+```
+
+## Tips
+
+- Use `fill` for pasted text and multi-line input.
+- Use `type` when the app reacts to individual keystrokes.
+- Use `press-key` for Enter, Tab, arrow keys, Escape, and control-key chords.
+- Use `wait-for --literal` for exact string matching.
+- Default terminal size is 120x40.

package/node_modules/@poe-code/agent-skill-config/dist/templates.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateLoader } from "@poe-code/config-mutations";
+export declare function loadTemplate(templateId: string): Promise<string>;
+export declare function createTemplateLoader(): TemplateLoader;

package/node_modules/@poe-code/agent-skill-config/dist/templates.js

@@ -0,0 +1,63 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const TEMPLATE_IDS = ["poe-generate.md", "terminal-pilot.md"];
+const cache = new Map();
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function findPackageRoot(entryFilePath) {
+    let current = path.dirname(entryFilePath);
+    while (true) {
+        if (await pathExists(path.join(current, "package.json"))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error("Unable to locate package root for agent-skill-config templates.");
+        }
+        current = parent;
+    }
+}
+async function resolveTemplatePath(templateId) {
+    const packageRoot = await findPackageRoot(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.join(packageRoot, "src", "templates", templateId),
+        path.join(packageRoot, "dist", "templates", templateId),
+        path.join(packageRoot, "dist", "templates", "skill", templateId)
+    ];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Template not found: ${templateId}`);
+}
+function isKnownTemplate(templateId) {
+    return TEMPLATE_IDS.includes(templateId);
+}
+export async function loadTemplate(templateId) {
+    if (!isKnownTemplate(templateId)) {
+        throw new Error(`Template not found: ${templateId}`);
+    }
+    const cached = cache.get(templateId);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const resolved = await resolveTemplatePath(templateId);
+    const content = await readFile(resolved, "utf8");
+    cache.set(templateId, content);
+    return content;
+}
+export function createTemplateLoader() {
+    return loadTemplate;
+}

package/node_modules/@poe-code/agent-skill-config/dist/types.d.ts

@@ -0,0 +1,16 @@
+import type { FileSystem, MutationObservers } from "@poe-code/config-mutations";
+import type { SkillScope } from "./configs.js";
+export interface ApplyOptions {
+    fs: FileSystem;
+    homeDir: string;
+    cwd: string;
+    scope?: SkillScope;
+    dryRun?: boolean;
+    observers?: MutationObservers;
+}
+export interface SkillFile {
+    /** Skill folder name */
+    name: string;
+    /** Content to write to SKILL.md */
+    content: string;
+}

package/node_modules/@poe-code/agent-skill-config/dist/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@poe-code/agent-skill-config/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@poe-code/agent-skill-config",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc && node scripts/copy-templates.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@poe-code/agent-defs": "*",
+    "@poe-code/config-mutations": "*"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-pilot",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Playwright-like SDK and CLI for automating interactive CLI apps through a real PTY",
   "type": "module",
   "main": "dist/index.js",
@@ -24,7 +24,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc --emitDeclarationOnly && node scripts/build.mjs",
-    "prepack": "node ../../scripts/set-bin-executable.mjs",
+    "prepack": "node ../../scripts/set-bin-executable.mjs && node ../../scripts/manage-bundled-workspace-deps.mjs prepare . @poe-code/agent-skill-config",
+    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . @poe-code/agent-skill-config",
     "test": "cd ../.. && vitest run $(rg --files packages/terminal-pilot/src -g '*.test.ts' | sort | tr '\n' ' ')",
     "test:unit": "cd ../.. && vitest run $(rg --files packages/terminal-pilot/src -g '*.test.ts' | sort | tr '\n' ' ')",
     "qa:cli": "cd ../.. && tsx packages/terminal-pilot/src/testing/qa-cli.ts",
@@ -60,6 +61,7 @@
     "jsonc-parser": "^3.3.1",
     "node-pty": "^1.1.0",
     "smol-toml": "^1.6.0",
+    "toolcraft-design": "^0.0.2",
     "yaml": "^2.8.2"
   },
   "bundleDependencies": [