@anhlp/alp-protocol 0.0.1-beta.3 → 0.0.1-beta.4

package/dist/schedule.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A scheduled continuation: a one-shot job that opens a new turn on a root session at a
+ * given time, without a user message. The protocol owns the shape so every
+ * client (the CLI, a viewer, an agent tool) reads the same state.
+ */
+/** Where a job stands: waiting for its time, delivered, failed, or cancelled before it fired. */
+export type ScheduleStatus = 'pending' | 'delivered' | 'failed' | 'cancelled';
+/** Why a job failed or still waits; failed may mean execution is unknown. */
+export type ScheduleError = {
+    message: string;
+    code?: string;
+};
+/** One job as `schedule.list` and `schedule.get` answer it. */
+export type ScheduleJob = {
+    /** The job's own id, `sch_` and sixteen hex digits. */
+    id: string;
+    /** The project whose root session the job continues. */
+    projectRoot: string;
+    /** The root session the job opens a turn on. */
+    sessionId: string;
+    /** The continuation the job delivers. */
+    prompt: string;
+    /** When the job is due, in UTC (ISO 8601). */
+    dueAt: string;
+    status: ScheduleStatus;
+    /**
+     * How many times alpd tried to deliver the job. A job delivered once may have been
+     * tried twice: a retry after a crash reads the receipt of the first delivery.
+     */
+    attempts: number;
+    createdAt: string;
+    updatedAt: string;
+    /** When the job was delivered, failed or cancelled. */
+    deliveredAt?: string;
+    failedAt?: string;
+    cancelledAt?: string;
+    /** When the first delivery was tried. */
+    attemptedAt?: string;
+    /** How late the delivery was, in milliseconds; 0 when it was on time. */
+    lateByMs?: number;
+    /** The last error of the job: why it failed, or why it still waits. */
+    lastError?: ScheduleError;
+};

package/dist/session.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimeKind } from './dto.js';
-import type { SessionSnapshot } from './events.js';
+import type { SessionSnapshot, TurnAttention } from './events.js';
 /** MCP servers a client adds to the agent's own; the agent's names win no collisions. */
 export type HostMcpServer = {
     type: 'stdio';
@@ -38,6 +38,8 @@ export type SessionSpec = {
             maxPeers: number;
             supervisor?: boolean;
         };
+        /** Claude: `threadId` does not exist yet and is made from this conversation on its first prompt (a fork or rewind, §12.7). */
+        base?: NativeBase;
     };
     /** Where the native harness works, when not the project root: an assignment's git worktree. ALP files are still read from cwd. */
     workdir?: string;
@@ -60,13 +62,34 @@ export type PromptImage = {
     data: string;
     name?: string;
 };
-/** Text parts carry `text`; image parts (`type: 'image'`) carry PromptImage's fields. */
+/** A stored attachment in a prompt (capability `attachments`, §12.6): its opaque id only, never a path or URL. */
+export type PromptAttachment = {
+    type: 'attachment';
+    attachmentId: string;
+};
+/**
+ * What alpd hands a runtime for an attachment part once it validated and pinned it (§12.6, the
+ * runtime seam of issue #121 branch J): ids, display metadata and digest, never a host path. The
+ * runtime reads the bytes through the AttachmentReader alpd binds, and only for a session whose
+ * runtime declared it takes attachments.
+ */
+export type RuntimeAttachment = {
+    type: 'attachment';
+    attachmentId: string;
+    name: string;
+    mimeType: string;
+    detectedMimeType: string;
+    size: number;
+    sha256: string;
+};
+/** Text parts carry `text`; image parts (`type: 'image'`) carry PromptImage's fields; attachment parts (`type: 'attachment'`) `attachmentId`. */
 export type PromptContent = Array<{
     type: string;
     text?: string;
     mimeType?: string;
     data?: string;
     name?: string;
+    attachmentId?: string;
 }>;
 export type PromptInput = {
     clientMessageId: string;
@@ -139,7 +162,124 @@ export type SessionSummary = SessionSnapshot & {
     status: SessionStatus;
     title?: string;
     archived?: boolean;
+    /** A root's turn that ended unseen, until a client acknowledges it (capability `session.attention`). */
+    attention?: TurnAttention;
     lastError?: SessionError;
     createdAt?: string;
     updatedAt?: string;
+    /**
+     * Whether alpd can fork or rewind this session's conversation now, and why not (capabilities
+     * `session.fork` and `session.rewind`, §12.7). A single turn may still be refused: one in
+     * progress, the first one, or one alpd cannot map to the runtime's own history.
+     */
+    conversation?: {
+        fork: boolean;
+        rewind: boolean;
+        /** Whether session.reload can restart this root's native process (capability `session.reload`, §12.8); the root must also be open and idle. */
+        reload?: boolean;
+        /** Whether session.configure can change this root's model, effort or team (capability `session.configure.live`, §12.9); the root must also be open and idle. */
+        configure?: boolean;
+        reason?: 'runtime_unsupported' | 'not_persistent' | 'not_root';
+    };
+    /** The session this root was forked from (§12.7). */
+    forkedFrom?: ForkProvenance;
+    /** Conversation branches rewinds set aside, oldest first; each stays recoverable with session.fork { branchId } (§12.7). */
+    branches?: ConversationBranch[];
+};
+/**
+ * A Claude conversation ALP has bound a session to but the runtime has not written yet (§12.7): the
+ * first prompt resumes `threadId` as a new session, keeping its history through the entry `at` (all of
+ * it when absent). Internal to alpd and its runtime; never accepted from a remote client.
+ */
+export type NativeBase = {
+    threadId: string;
+    at?: string;
+};
+/** Where a fork came from (§12.7): the source root, and the turn its conversation was cut at. */
+export type ForkProvenance = {
+    sessionId: string;
+    /** The cut: through this turn, or before it; absent when the whole conversation was taken. */
+    turnId?: string;
+    boundary: 'through' | 'before' | 'whole';
+    /** Set when the fork restored a branch a rewind set aside. */
+    branchId?: string;
+    at: string;
+};
+/** The later turns of a conversation a rewind set aside (§12.7): kept, never deleted, recoverable as a new session. */
+export type ConversationBranch = {
+    branchId: string;
+    /** The turn the rewind went back to before; it and every later turn are in the branch. */
+    beforeTurnId: string;
+    /** How many turns the branch holds past the kept conversation. */
+    turns: number;
+    at: string;
+};
+/**
+ * The ALP CLI command that continues a session in a terminal (session.resumeCommand, §12.8): `argv`
+ * and the same command quoted for a POSIX shell and for Windows (cmd.exe). `display` is the one for
+ * the daemon host's own platform. Never a native runtime's command, credential, env or path.
+ */
+export type ResumeCommand = {
+    argv: string[];
+    posix: string;
+    windows: string;
+    display: string;
+    platform: 'posix' | 'windows';
+};
+/**
+ * The configuration a root runs with, or would after a change, as alpd resolved it (§12.9): its team,
+ * agent, runtime, model, effort and mode, and what they bring (delegation targets, ALP tools, MCP
+ * servers by name and kind, hook count, an instructions digest). Never a path, command or credential.
+ */
+export type EffectiveConfig = {
+    team: string;
+    teamLabel?: string;
+    agent: string;
+    runtime: RuntimeKind;
+    model: string;
+    thinking: string;
+    mode: string;
+    /** The permission profile capping the agent's mode, when one does. */
+    permissionProfile?: string;
+    supervisor: boolean;
+    maxPeers?: number;
+    delegates: string[];
+    tools: string[];
+    mcpServers: Array<{
+        name: string;
+        kind: 'stdio' | 'http';
+    }>;
+    hooks: number;
+    instructionsSha?: string;
+};
+export type ConfigureChange = 'model' | 'thinking' | 'team' | 'mode';
+export type ConfigureRefusal = 'session_busy' | 'session_closed' | 'not_root' | 'runtime_unsupported' | 'runtime_mismatch' | 'agent_mismatch' | 'permission_escalation' | 'team_not_found' | 'invalid_params' | 'not_persistent';
+/** session.configure.preview (§12.9): the current and proposed configuration, and whether alpd would apply it now. */
+export type ConfigurePreview = {
+    current: EffectiveConfig;
+    proposed: EffectiveConfig;
+    changes: ConfigureChange[];
+    /** Applying it restarts the root's native process on its own conversation. */
+    restart: boolean;
+    /** session.configure would take it now; a tree that gets busy meanwhile still refuses it. */
+    allowed: boolean;
+    reason?: ConfigureRefusal;
+    message?: string;
+    teams: Array<{
+        id: string;
+        label: string;
+        description?: string;
+    }>;
+};
+/** What a session.configure with model, thinking or team did (§12.9): what was asked, and what the root runs with now. */
+export type ConfigureOutcome = {
+    status: 'applied' | 'unchanged';
+    requested: {
+        model?: string;
+        thinking?: string;
+        team?: string;
+        mode?: string;
+    };
+    effective: EffectiveConfig;
+    restarted: boolean;
 };

package/dist/wire.d.ts

@@ -1,3 +1,9 @@
+/**
+ * The decoded bytes one attachment.chunk may carry over frames of at most `maxFrame` bytes:
+ * `maxChunkBytes`, lowered so its base64 and ATTACHMENT_CHUNK_OVERHEAD fit. At least 1 byte.
+ * @param {number} [maxFrame] @param {number} [maxChunkBytes]
+ */
+export function attachmentChunkBytes(maxFrame?: number, maxChunkBytes?: number): number;
 /**
  * Whether a path relative to a workspace names something workspace.files.list and
  * workspace.files.read never show, whatever the grant: a segment that is a blocked directory, or
@@ -11,6 +17,31 @@ export function blockedFilePath(relative: string): boolean;
 export function encodeFrame(value: unknown): string;
 /** Parse one complete frame. Buffering and failure handling belong to the socket owner. @param {string} line @returns {unknown} */
 export function decodeFrame(line: string): unknown;
+/** One argument for a POSIX shell: as it is when nothing in it is special, else in single quotes. @param {string} arg */
+export function quotePosix(arg: string): string;
+/**
+ * One argument for cmd.exe: as it is when nothing in it is special; else in double quotes for the C
+ * runtime's split (backslashes before the closing quote doubled), with every cmd.exe metacharacter,
+ * the quotes too, escaped with ^ for the interactive parse; the shim's second parse then sees one
+ * quoted argument, inside which `&|<>()^` are literal. `"`, `%` and `!` are refused (see above).
+ * @param {string} arg
+ */
+export function quoteWindows(arg: string): string;
+/** argv as one command line. @param {string[]} argv @param {'posix' | 'windows'} platform */
+export function commandLine(argv: string[], platform: "posix" | "windows"): string;
+/**
+ * session.resumeCommand's answer for a session: `alp attach <sessionId>`, which follows the session in
+ * a terminal (a closed one says how to send it a message). ALP keeps the orchestration, so it is never
+ * a native runtime's own resume command.
+ * @param {string} sessionId @param {'posix' | 'windows'} platform the daemon host's
+ */
+export function resumeCommandOf(sessionId: string, platform: "posix" | "windows"): {
+    argv: string[];
+    posix: string;
+    windows: string;
+    display: string;
+    platform: "posix" | "windows";
+};
 /** Wire protocol of alpd (plans/reference/ALPD.md §3). Bump only for incompatible changes. */
 export const PROTOCOL_VERSION: 1;
 export const MAX_FRAME: number;
@@ -39,7 +70,12 @@ export const RPC_ERROR: Readonly<{
  * a daemon that lists none (one older than this list) has none of them. Unknown names are ignored.
  */
 export const CAPABILITY: Readonly<{
+    sessionInterruptTurn: "session.interrupt.turn";
     attachAfter: "attach.after";
+    sessionHistory: "session.history";
+    workspaceRegistry: "workspace.registry";
+    workspaceWorktree: "workspace.worktree";
+    workspaceGit: "workspace.git";
     promptReceipts: "prompt.receipts";
     extensionMethods: "extension.methods";
     team: "team";
@@ -50,9 +86,18 @@ export const CAPABILITY: Readonly<{
     sessionListPage: "session.list.page";
     questionWatch: "question.watch";
     questionWatchTurns: "question.watch.turns";
+    sessionAttention: "session.attention";
     workspaceFiles: "workspace.files";
     workspaceFilesRead: "workspace.files.read";
     promptImages: "prompt.images";
+    schedule: "schedule";
+    attachments: "attachments";
+    sessionFork: "session.fork";
+    sessionRewind: "session.rewind";
+    sessionReload: "session.reload";
+    sessionResumeCommand: "session.resumeCommand";
+    sessionConfigureLive: "session.configure.live";
+    terminal: "terminal";
 }>;
 /**
  * What alpd takes as images in one session.prompt (capability `prompt.images`): inline base64 of
@@ -78,3 +123,70 @@ export const WORKSPACE_FILES: Readonly<{
     maxListEntries: 1000;
     maxPathLength: 4096;
 }>;
+/**
+ * Limits of workspace.git.status and workspace.git.diff (capability `workspace.git`,
+ * docs/protocol/alp-json-rpc-v1.md §12.5): one file's patch at most `maxFileBytes`, one page's
+ * patches at most `maxTotalBytes` (then `nextCursor`), at most `maxUntracked` untracked files with
+ * content, `maxStatusFiles` status rows, a base branch name of at most `maxRefLength` characters.
+ * A gateway may lower them; never raise them.
+ */
+export const WORKSPACE_GIT: Readonly<{
+    maxFileBytes: number;
+    maxTotalBytes: number;
+    maxUntracked: 200;
+    maxStatusFiles: 1000;
+    maxRefLength: 255;
+}>;
+/**
+ * Limits of non-image attachments (capability `attachments`, docs/protocol/alp-json-rpc-v1.md
+ * §12.6): an object of at most `maxObjectBytes`; a prompt of at most `maxPerPrompt` attachments and
+ * `maxPromptBytes` together; chunks of at most `maxChunkBytes` decoded (lowered further by
+ * attachmentChunkBytes to fit a frame); `maxActiveUploads` incomplete uploads and
+ * `maxPrincipalBytes` stored per principal, `maxDaemonBytes` per daemon, retained references
+ * included. An incomplete upload expires after `uploadTimeoutMs`; an unreferenced committed object
+ * is purged after `unreferencedRetentionMs`, one whose references were all released after
+ * `releasedGraceMs`. A display name is at most `maxNameBytes` UTF-8 bytes. An operator or a gateway
+ * may lower them, never raise them; daemon.hello advertises the effective ones (`attachmentLimits`).
+ */
+export const ATTACHMENTS: Readonly<{
+    maxObjectBytes: number;
+    maxPerPrompt: 8;
+    maxPromptBytes: number;
+    maxChunkBytes: number;
+    maxActiveUploads: 2;
+    maxPrincipalBytes: number;
+    maxDaemonBytes: number;
+    uploadTimeoutMs: number;
+    unreferencedRetentionMs: number;
+    releasedGraceMs: number;
+    maxNameBytes: 255;
+}>;
+/**
+ * Limits of terminals (capability `terminal`, docs/protocol/alp-json-rpc-v1.md §12.10): at most
+ * `maxPerPrincipal` running terminals per principal and `maxPerDaemon` per daemon; a
+ * terminal.input of at most `maxInputBytes` UTF-8 bytes; output events of at most
+ * `maxOutputFrameBytes` bytes of data; `replayBytes` of output kept per terminal for attach; a
+ * terminal ends after `idleMs` without input or output, after `maxLifetimeMs` in any case, and
+ * `reconnectMs` after its stream detached unless attached again. Sizes are `minCols`..`maxCols`
+ * columns and `minRows`..`maxRows` rows. An operator or a gateway may lower the first eight, never
+ * raise them; daemon.hello advertises the effective ones (`terminalLimits`).
+ */
+export const TERMINAL: Readonly<{
+    maxPerPrincipal: 4;
+    maxPerDaemon: 16;
+    maxInputBytes: number;
+    maxOutputFrameBytes: number;
+    replayBytes: number;
+    idleMs: number;
+    maxLifetimeMs: number;
+    reconnectMs: number;
+    minCols: 2;
+    maxCols: 500;
+    minRows: 1;
+    maxRows: 200;
+}>;
+/** The TERMINAL limits a daemon.hello `terminalLimits` carries (the size bounds are fixed). */
+export const TERMINAL_LIMIT_KEYS: readonly string[];
+export function isTerminalId(id: unknown): boolean;
+/** Room an attachment.chunk request needs besides its base64 data. */
+export const ATTACHMENT_CHUNK_OVERHEAD: number;

package/dist/wire.js

@@ -10,11 +10,46 @@ var AlpRpcError = class extends Error {
 };
 var ERROR = Object.freeze({ failed: 1e3, notFound: 1001, forbidden: 1003, conflict: 1004, unavailable: 1005, protocol: 1006 });
 var RPC_ERROR = Object.freeze({ parseError: -32700, invalidRequest: -32600, methodNotFound: -32601, invalidParams: -32602 });
-var CAPABILITY = Object.freeze({ attachAfter: "attach.after", promptReceipts: "prompt.receipts", extensionMethods: "extension.methods", team: "team", task: "task", library: "library", libraryProjectWrite: "library.project.write", settingsLanguage: "settings.language", sessionListPage: "session.list.page", questionWatch: "question.watch", questionWatchTurns: "question.watch.turns", workspaceFiles: "workspace.files", workspaceFilesRead: "workspace.files.read", promptImages: "prompt.images" });
+var CAPABILITY = Object.freeze({ sessionInterruptTurn: "session.interrupt.turn", attachAfter: "attach.after", sessionHistory: "session.history", workspaceRegistry: "workspace.registry", workspaceWorktree: "workspace.worktree", workspaceGit: "workspace.git", promptReceipts: "prompt.receipts", extensionMethods: "extension.methods", team: "team", task: "task", library: "library", libraryProjectWrite: "library.project.write", settingsLanguage: "settings.language", sessionListPage: "session.list.page", questionWatch: "question.watch", questionWatchTurns: "question.watch.turns", sessionAttention: "session.attention", workspaceFiles: "workspace.files", workspaceFilesRead: "workspace.files.read", promptImages: "prompt.images", schedule: "schedule", attachments: "attachments", sessionFork: "session.fork", sessionRewind: "session.rewind", sessionReload: "session.reload", sessionResumeCommand: "session.resumeCommand", sessionConfigureLive: "session.configure.live", terminal: "terminal" });
 var PROMPT_IMAGES = Object.freeze({ mimeTypes: Object.freeze(["image/png", "image/jpeg", "image/gif", "image/webp"]), maxCount: 8, maxBytes: 5 * 1024 * 1024, maxTotalBytes: 11 * 1024 * 1024 });
 var base64Bytes = (data) => Math.floor(data.length * 3 / 4) - (data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0);
-var RPC_METHODS = Object.freeze(["assignment.recall", "board.list", "catalog.get", "daemon.hello", "daemon.pause", "daemon.pauses", "daemon.resume", "daemon.shutdown", "daemon.status", "daemon.usage", "extension.register", "extension.unregister", "library.delete", "library.duplicate", "library.get", "library.list", "library.models", "library.rename", "library.save", "library.skills.set", "question.answer", "question.list", "question.watch", "session.archive", "session.attach", "session.close", "session.configure", "session.create", "session.get", "session.interrupt", "session.list", "session.log", "session.message", "session.preview", "session.prompt", "session.release", "session.rename", "session.status", "settings.language.get", "settings.language.set", "task.create", "task.gate.resolve", "task.list", "task.update", "team.list", "workspace.files.list", "workspace.files.read", "workspace.files.search"]);
+var RPC_METHODS = Object.freeze(["assignment.recall", "attachment.abort", "attachment.begin", "attachment.chunk", "attachment.commit", "attachment.delete", "attachment.get", "board.list", "catalog.get", "daemon.hello", "daemon.pause", "daemon.pauses", "daemon.resume", "daemon.shutdown", "daemon.status", "daemon.usage", "extension.register", "extension.unregister", "library.delete", "library.duplicate", "library.get", "library.list", "library.models", "library.rename", "library.save", "library.skills.set", "project.list", "project.register", "project.remove", "question.answer", "question.list", "question.watch", "registry.owner", "registry.worktree", "schedule.cancel", "schedule.create", "schedule.get", "schedule.list", "session.archive", "session.attach", "session.attention.clear", "session.close", "session.configure", "session.configure.preview", "session.create", "session.fork", "session.get", "session.history", "session.interrupt", "session.list", "session.log", "session.message", "session.preview", "session.prompt", "session.release", "session.reload", "session.rename", "session.resumeCommand", "session.rewind", "session.status", "settings.language.get", "settings.language.set", "task.create", "task.gate.resolve", "task.list", "task.update", "team.list", "terminal.attach", "terminal.close", "terminal.create", "terminal.input", "terminal.list", "terminal.resize", "terminal.revoke", "workspace.files.list", "workspace.files.read", "workspace.files.search", "workspace.get", "workspace.git.diff", "workspace.git.status", "workspace.list", "workspace.update", "workspace.worktree.create", "workspace.worktree.options", "workspace.worktree.remove"]);
 var WORKSPACE_FILES = Object.freeze({ maxReadBytes: 1024 * 1024, maxListEntries: 1e3, maxPathLength: 4096 });
+var WORKSPACE_GIT = Object.freeze({ maxFileBytes: 1024 * 1024, maxTotalBytes: 2 * 1024 * 1024, maxUntracked: 200, maxStatusFiles: 1e3, maxRefLength: 255 });
+var ATTACHMENTS = Object.freeze({
+  maxObjectBytes: 20 * 1024 * 1024,
+  maxPerPrompt: 8,
+  maxPromptBytes: 40 * 1024 * 1024,
+  maxChunkBytes: 256 * 1024,
+  maxActiveUploads: 2,
+  maxPrincipalBytes: 200 * 1024 * 1024,
+  maxDaemonBytes: 1024 * 1024 * 1024,
+  uploadTimeoutMs: 60 * 60 * 1e3,
+  unreferencedRetentionMs: 24 * 60 * 60 * 1e3,
+  releasedGraceMs: 7 * 24 * 60 * 60 * 1e3,
+  maxNameBytes: 255
+});
+var TERMINAL = Object.freeze({
+  maxPerPrincipal: 4,
+  maxPerDaemon: 16,
+  maxInputBytes: 64 * 1024,
+  maxOutputFrameBytes: 64 * 1024,
+  replayBytes: 1024 * 1024,
+  idleMs: 30 * 60 * 1e3,
+  maxLifetimeMs: 8 * 60 * 60 * 1e3,
+  reconnectMs: 60 * 1e3,
+  minCols: 2,
+  maxCols: 500,
+  minRows: 1,
+  maxRows: 200
+});
+var TERMINAL_LIMIT_KEYS = Object.freeze(["maxPerPrincipal", "maxPerDaemon", "maxInputBytes", "maxOutputFrameBytes", "replayBytes", "idleMs", "maxLifetimeMs", "reconnectMs"]);
+var isTerminalId = (id) => typeof id === "string" && /^term_[0-9a-f]{32}$/.test(id);
+var ATTACHMENT_CHUNK_OVERHEAD = 64 * 1024;
+function attachmentChunkBytes(maxFrame = MAX_FRAME, maxChunkBytes = ATTACHMENTS.maxChunkBytes) {
+  const fits = Math.floor((maxFrame - ATTACHMENT_CHUNK_OVERHEAD) * 3 / 4);
+  return Math.max(1, Math.min(maxChunkBytes, fits));
+}
 var BLOCKED_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".alp", ".ssh", ".gnupg", ".aws", ".azure", ".kube", ".docker", "gcloud"]);
 var BLOCKED_NAMES = /* @__PURE__ */ new Set([".netrc", "_netrc", ".npmrc", ".yarnrc.yml", ".pypirc", ".pgpass", ".htpasswd", ".git-credentials", ".dockercfg", ".boto", ".s3cfg", ".mcp.json", "auth.json", "kubeconfig", "settings.local.json", ".vault-token", "application_default_credentials.json", "token.json"]);
 var BLOCKED_PAIRS = /* @__PURE__ */ new Set(["gh/hosts.yml"]);
@@ -45,7 +80,38 @@ function encodeFrame(value) {
 function decodeFrame(line) {
   return JSON.parse(line);
 }
+var POSIX_SAFE = /^[A-Za-z0-9_@+:,./-]+$/;
+var WINDOWS_SAFE = /^[A-Za-z0-9_@+:./\\-]+$/;
+var assertArgument = (arg) => {
+  if (typeof arg !== "string") throw new TypeError("A command argument is a string");
+  if (/[\u0000-\u001f\u007f]/.test(arg)) throw new TypeError("A command argument has no control characters");
+  return arg;
+};
+function quotePosix(arg) {
+  const text = assertArgument(arg);
+  return text && POSIX_SAFE.test(text) ? text : `'${text.replace(/'/g, `'\\''`)}'`;
+}
+function quoteWindows(arg) {
+  const text = assertArgument(arg);
+  if (text && WINDOWS_SAFE.test(text)) return text;
+  if (/["%!]/.test(text)) throw new TypeError('A cmd.exe command argument has no ", % or !');
+  const quoted = `"${text.replace(/(\\*)$/, "$1$1")}"`;
+  return quoted.replace(/([()\][^"`<>&|;, *?])/g, "^$1");
+}
+var SESSION_ID = /^[\w.:-]{1,128}$/;
+function commandLine(argv, platform) {
+  return argv.map(platform === "windows" ? quoteWindows : quotePosix).join(" ");
+}
+function resumeCommandOf(sessionId, platform) {
+  if (typeof sessionId !== "string" || !SESSION_ID.test(sessionId)) throw new TypeError("A session id is [A-Za-z0-9_.:-], at most 128 characters");
+  const argv = ["alp", "attach", sessionId];
+  const posix = commandLine(argv, "posix");
+  const windows = commandLine(argv, "windows");
+  return { argv, posix, windows, display: platform === "windows" ? windows : posix, platform };
+}
 export {
+  ATTACHMENTS,
+  ATTACHMENT_CHUNK_OVERHEAD,
   AlpRpcError,
   CAPABILITY,
   ERROR,
@@ -54,9 +120,18 @@ export {
   PROTOCOL_VERSION,
   RPC_ERROR,
   RPC_METHODS,
+  TERMINAL,
+  TERMINAL_LIMIT_KEYS,
   WORKSPACE_FILES,
+  WORKSPACE_GIT,
+  attachmentChunkBytes,
   base64Bytes,
   blockedFilePath,
+  commandLine,
   decodeFrame,
-  encodeFrame
+  encodeFrame,
+  isTerminalId,
+  quotePosix,
+  quoteWindows,
+  resumeCommandOf
 };