agentus 0.1.0 → 0.3.0

package/packages/server/src/store/store.ts

@@ -75,6 +75,9 @@ export interface SessionRow {
   pid: number | null;
   createdAt: number;
   closedAt: number | null;
+  /** When the OPERATOR put this session away (已归档). Null = it belongs in 工作空间. A storage
+   *  state: it says nothing about whether a process is running (see SessionInfo.archivedAt). */
+  archivedAt: number | null;
   /** JSON round-trip of the ACP mode state + config options, so a resumed
    *  session (M4-lite) comes back with the operator's mode/effort intact. */
   modes?: unknown;
@@ -105,7 +108,7 @@ export interface SessionRow {
 interface RawSessionRow {
   id: string; backend: BackendId; acp_session_id: string | null; cwd: string;
   title: string; auto_title?: string | null; status: SessionStatus; pid: number | null;
-  created_at: number; closed_at: number | null;
+  created_at: number; closed_at: number | null; archived_at?: number | null;
   modes?: string | null; config_options?: string | null;
   usage?: string | null; commands?: string | null;
   workspace?: string | null;
@@ -169,7 +172,7 @@ function rowToSession(r: RawSessionRow): SessionRow {
   return {
     id: r.id, backend: r.backend, acpSessionId: r.acp_session_id, cwd: r.cwd,
     title: r.title, autoTitle: r.auto_title ?? null, status: r.status, pid: r.pid,
-    createdAt: r.created_at, closedAt: r.closed_at,
+    createdAt: r.created_at, closedAt: r.closed_at, archivedAt: r.archived_at ?? null,
     modes: parseJson(r.modes), configOptions: parseJson(r.config_options) ?? [],
     usage: parseJson(r.usage), commands: parseJson(r.commands) ?? [],
     workspace: r.workspace ?? null,
@@ -182,6 +185,7 @@ function rowToSession(r: RawSessionRow): SessionRow {
 interface RawBackendRow {
   id: string; label: string; kind: string; cmd: string; args: string; env: string;
   home: string | null; profile: string | null; cwd: string | null; notes: string;
+  default_mode: string | null;
   native_plan_source: string | null;
   builtin: number; created_at: number; updated_at: number;
   // health snapshot (M6.1) — system-written, see registry.BackendHealth
@@ -212,6 +216,9 @@ function rowToBackend(r: RawBackendRow): BackendRow {
     home: r.home ?? null,
     profile: r.profile ?? null,
     cwd: r.cwd ?? null,
+    // A row predating the column (or a seeded one) says nothing: send no mode at all, so the agent
+    // keeps its own default. No mode name is invented here — "缺省" must mean "不上手".
+    defaultMode: (r.default_mode ?? "").trim() || null,
     notes: r.notes ?? "",
     builtin: r.builtin === 1,
     health: {
@@ -304,6 +311,8 @@ export class Store {
         id text primary key, label text not null, kind text not null,
         cmd text not null, args text not null default '[]', env text not null default '{}',
         home text, profile text, cwd text, notes text not null default '',
+        -- the ACP mode a NEW session from this row starts in (null = the agent's own default)
+        default_mode text,
         builtin integer not null default 0,
         created_at integer not null, updated_at integer not null
       );
@@ -334,6 +343,13 @@ export class Store {
     this.#db.exec("update sessions set auto_title = title where auto_title is null or auto_title = ''");
     // integer column, so it gets its own migration (the loop above assumes text)
     if (!cols.has("context_limit")) this.#db.exec("alter table sessions add column context_limit integer");
+    // WHEN THE OPERATOR PUT THE SESSION AWAY (已归档 — a STORAGE state). Before this column the rail
+    // inferred "archived" from "has no process", so a slot that merely crashed (or was killed by an
+    // idle reap) filed itself under 已归档 next to the ones the operator really put away, and
+    // 「我在归档一栏里看到的」 stopped meaning anything. NULL is the honest default for every existing
+    // row: nobody ever archived them, they were just dead. The 已归档 section starts empty and fills
+    // with what the operator actually archives.
+    if (!cols.has("archived_at")) this.#db.exec("alter table sessions add column archived_at integer");
     // The session's own ACTIVITY clock — when the operator or the agent last really said something
     // in it. A COLUMN, not a derived `max(messages.created_at)` (AionUi's model: `modified_at` on
     // the conversation row, indexed, which is what its sidebar sorts by): every ingestion path
@@ -362,6 +378,9 @@ export class Store {
       // P1 (plan service): which channel carries this backend's plan, `acp` | `none`. Nullable on
       // purpose — a row that predates it follows the same default as a seeded one (see rowToBackend).
       "native_plan_source",
+      // The permission mode a new session starts in. Nullable like the rest: a row that predates the
+      // column means "send nothing" (the agent's own default), not "some mode we invented".
+      "default_mode",
     ]) {
       if (!beCols.has(col)) this.#db.exec(`alter table backends add column ${col} text`);
     }
@@ -693,6 +712,16 @@ export class Store {
     }
   }
 
+  /** Put this session away — or take it back out (已归档). Its OWN statement, like `home`: the
+   *  archive flag is the one thing the operator sets directly, and a routine row upsert (a status
+   *  change, a rename, an idle reap) must not be able to clear it. Returns whether a row matched. */
+  setArchived(sessionId: string, at: number | null): boolean {
+    const info = this.#db
+      .prepare("update sessions set archived_at = ? where id = ?")
+      .run(at, sessionId);
+    return Number(info.changes ?? 0) > 0;
+  }
+
   /** Record (or adopt) the home a session was created under. Used when a legacy row — created
    *  before the column existed — is resumed successfully: the successful load is itself the
    *  proof of which home holds its state, so the row stops being ambiguous. */
@@ -1153,16 +1182,18 @@ export class Store {
     this.#db
       .prepare(
         `insert into backends (id, label, kind, cmd, args, env, home, profile, cwd, notes,
+                               default_mode,
                                native_plan_source,
                                builtin, created_at, updated_at,
                                last_check_status, last_check_kind, last_check_error_code,
                                last_check_error_message, last_check_guidance, last_check_latency_ms,
                                last_check_at, last_success_at, last_failure_at, handshake, handshake_at)
-         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          on conflict(id) do update set
            label = excluded.label, kind = excluded.kind, cmd = excluded.cmd, args = excluded.args,
            env = excluded.env, home = excluded.home, profile = excluded.profile, cwd = excluded.cwd,
            notes = excluded.notes,
+           default_mode = excluded.default_mode,
            native_plan_source = excluded.native_plan_source,
            updated_at = excluded.updated_at,
            -- the evidence travels with the row: a spawn-relevant edit replaces it with a cleared
@@ -1179,6 +1210,7 @@ export class Store {
       .run(
         row.id, row.label, row.kind, row.cmd, JSON.stringify(row.args), JSON.stringify(row.env ?? {}),
         row.home, row.profile, row.cwd, row.notes ?? "",
+        row.defaultMode ?? null,
         row.nativePlanSource ?? null,
         row.builtin ? 1 : 0, row.createdAt, row.updatedAt,
         row.health?.status ?? null, row.health?.kind ?? null, row.health?.errorCode ?? null,

package/packages/server/src/term.ts

@@ -19,10 +19,11 @@
 //    because that is the directory the operator pointed this slot at. It is not
 //    a sandbox and does not pretend to be: the person running the cockpit already
 //    owns the machine (same trust model as the agent processes).
-import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
 
 export interface TermSession {
   id: string;
@@ -30,31 +31,53 @@ export interface TermSession {
   pid: number | null;
   /** bytes of output kept for a late joiner / a reconnect */
   buffer: string;
-  child: ChildProcessWithoutNullStreams;
+  child: ChildProcess;
   subscribers: Set<(chunk: string) => void>;
   exited: { code: number | null; signal: string | null } | null;
+  /** true when the child has a real tty (see shellCommand). The panel says which it got, because
+   *  a pipe shell and a tty look nothing alike and the operator should not have to guess. */
+  tty: boolean;
+  /** Resize the tty (no-op on a pipe shell). The kernel then SIGWINCHes the child's foreground
+   *  process group, which is what makes a full-screen program redraw at the new width. */
+  resize: (cols: number, rows: number) => void;
 }
 
 const MAX_BUFFER = 256 * 1024;
 
-/** How to start the shell. Default: pipes (no native deps). PTY on request. */
-function shellCommand(shell: string): { cmd: string; args: string[] } {
+/** The PTY helper that ships with the server. */
+function ptyHelperPath(): string | null {
+  for (const rel of ["./pty-helper.py", "../src/pty-helper.py"]) {
+    try {
+      const p = fileURLToPath(new URL(rel, import.meta.url));
+      if (fs.existsSync(p)) return p;
+    } catch {
+      /* not this layout */
+    }
+  }
+  return null;
+}
+
+/** How to start the shell.
+ *
+ *  Default is a REAL pty via `pty-helper.py` (python3 stdlib `forkpty`): the shell gets a controlling
+ *  terminal, so prompts, echo, colours, job control and full-screen programs behave. That is the
+ *  whole point of the panel — a terminal emulator in front of a pipe shell is a lie (no prompt lands
+ *  on screen, keystrokes are never echoed, resize means nothing).
+ *
+ *  Escapes: `AGENTUS_TERM_CMD` runs an arbitrary command line instead (pipes), `AGENTUS_TERM_PTY=0`
+ *  forces the old pipe shell, and a machine without python3 degrades to it automatically. Whoever
+ *  gets a pipe shell is told so in the panel rather than being shown a fake terminal. */
+function shellCommand(shell: string): { cmd: string; args: string[]; tty: boolean } {
   const override = (process.env.AGENTUS_TERM_CMD || "").trim();
   if (override) {
     const parts = override.split(/\s+/);
-    return { cmd: parts[0], args: parts.slice(1) };
+    return { cmd: parts[0], args: parts.slice(1), tty: false };
   }
-  if (process.env.AGENTUS_TERM_PTY === "1") {
-    // python3's stdlib pty module is the one pty allocation available without a
-    // native build step. Missing python3 fails loudly in the panel (the child
-    // prints the interpreter error into the terminal), which is better than
-    // silently degrading to a pipe shell that claims to be a tty.
-    return {
-      cmd: "python3",
-      args: ["-u", "-c", `import pty,sys; pty.spawn(${JSON.stringify([shell, "-i"])})`],
-    };
+  if (process.env.AGENTUS_TERM_PTY !== "0") {
+    const helper = ptyHelperPath();
+    if (helper) return { cmd: "python3", args: [helper, shell, "-i"], tty: true };
   }
-  return { cmd: shell, args: ["-i"] };
+  return { cmd: shell, args: ["-i"], tty: false };
 }
 
 function pickShell(): string {
@@ -69,9 +92,11 @@ function pickShell(): string {
 export class TermService {
   #sessions = new Map<string, TermSession>();
 
-  start(cwd: string): TermSession {
+  start(cwd: string, size?: { cols: number; rows: number }): TermSession {
     const shell = pickShell();
-    const { cmd, args } = shellCommand(shell);
+    const { cmd, args, tty } = shellCommand(shell);
+    const cols = Math.max(20, Math.min(size?.cols ?? 80, 1000));
+    const rows = Math.max(5, Math.min(size?.rows ?? 24, 1000));
     const child = spawn(cmd, args, {
       cwd: fs.existsSync(cwd) ? cwd : homedir(),
       env: {
@@ -80,13 +105,19 @@ export class TermService {
         PYTHONUNBUFFERED: "1",
         // Let the shell know a machine is driving, so prompts stay plain.
         AGENTUS_TERMINAL: "1",
+        // The pty is sized at start because the shell reads its size when it draws the first
+        // prompt — resizing afterwards still works, but a 80x24 flash on every open is not free.
+        AGENTUS_PTY_COLS: String(cols),
+        AGENTUS_PTY_ROWS: String(rows),
       },
-      stdio: ["pipe", "pipe", "pipe"],
-      // own process group: `script` wraps the shell, so only a group kill reliably
-      // takes both down (see kill()).
+      // fd 3 is the PTY helper's control channel (resize). A pipe shell has no use for it.
+      stdio: tty ? ["pipe", "pipe", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
+      // own process group: the shell (or the pty helper wrapping it) is killed as a group, never
+      // one process at a time (see kill()).
       detached: true,
-    }) as ChildProcessWithoutNullStreams;
+    }) as ChildProcess;
 
+    const ctl = tty ? ((child.stdio[3] ?? null) as NodeJS.WritableStream | null) : null;
     const session: TermSession = {
       id: randomUUID(),
       cwd,
@@ -95,6 +126,15 @@ export class TermService {
       child,
       subscribers: new Set(),
       exited: null,
+      tty,
+      resize: (c: number, r: number): void => {
+        if (!ctl) return;
+        try {
+          ctl.write(`resize ${Math.max(1, Math.min(c, 1000))} ${Math.max(1, Math.min(r, 1000))}\n`);
+        } catch {
+          /* the helper is gone; the exit event says so */
+        }
+      },
     };
     const push = (chunk: string): void => {
       session.buffer = (session.buffer + chunk).slice(-MAX_BUFFER);
@@ -106,17 +146,18 @@ export class TermService {
         }
       }
     };
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    // stderr is part of the terminal picture (a missing command prints there)
-    child.stdout.on("data", (d: string) => push(d));
-    child.stderr.on("data", (d: string) => push(d));
-    child.on("exit", (code, signal) => {
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    // stderr is part of the terminal picture (a missing command prints there). With a pty both
+    // streams are already merged into the pty master, so only stdout carries them — harmless.
+    child.stdout?.on("data", (d: string) => push(d));
+    child.stderr?.on("data", (d: string) => push(d));
+    child.on("exit", (code: number | null, signal: string | null) => {
       session.exited = { code, signal };
       push(`\r\n[process exited${code != null ? ` with code ${code}` : ""}${signal ? ` (${signal})` : ""}]\r\n`);
       this.#sessions.delete(session.id);
     });
-    child.on("error", (err) => push(`\r\n[cannot start shell: ${err.message}]\r\n`));
+    child.on("error", (err: Error) => push(`\r\n[cannot start shell: ${err.message}]\r\n`));
     this.#sessions.set(session.id, session);
     return session;
   }

package/packages/shared/src/index.ts

@@ -22,6 +22,7 @@ export type SessionStatus =
   | "starting" // subprocess spawned, initialize/newSession in flight
   | "ready" // accepts prompts
   | "running" // a prompt turn is in flight
+  | "reaped" // no process: it was idle past the operator's threshold (settings.agent.idleKillMin)
   | "error" // subprocess died or handshake failed
   | "closed";
 
@@ -74,6 +75,15 @@ export interface SessionInfo {
    *  This — not `createdAt`, and not `lastSeq` (a per-session counter) — is what the rail
    *  orders by: "which of these did I last talk to". */
   lastAt?: number;
+  /** The operator PUT THIS SESSION AWAY: it belongs in the rail's 已归档 section, whatever its
+   *  process is doing. This is a STORAGE state, not a liveness one — the rail used to infer
+   *  `archived` from `has no process`, which filed a crashed slot and a deliberately archived
+   *  one in the same place (the operator's complaint: 「我设想的点击归档是一种存储态」). */
+  archivedAt?: number | null;
+  /** No agent process right now — it was closed, it crashed, or it was REAPED for being idle.
+   *  Derived server-side and sent with the row, so the client never infers liveness from which
+   *  list a row arrived in (that inference is what merged 已归档 with 死了). */
+  cold?: boolean;
 }
 
 export interface AvailableCommandView {
@@ -148,7 +158,7 @@ export interface PermissionDiff {
 // ---- WS envelope (server -> browser) ----
 export type ServerEvent =
   | { t: "hello"; clientId: string; resumed: boolean }
-  | { t: "sessions"; sessions: SessionInfo[]; /** requests already waiting for an answer, so a page that connects or refreshes learns about them (they are STATE; the events happened before it existed) */ pending?: PermissionRequestView[] }
+  | { t: "sessions"; sessions: SessionInfo[]; /** rows on disk with NO process and no archive flag — they belong in 工作空间 beside the live ones (a crashed slot must not look archived, and must not vanish from the rail either) */ cold?: SessionInfo[]; /** rows the operator explicitly archived (archivedAt set) — the 已归档 section, whatever their process state */ archived?: SessionInfo[]; /** requests already waiting for an answer, so a page that connects or refreshes learns about them (they are STATE; the events happened before it existed) */ pending?: PermissionRequestView[] }
   | { t: "session"; session: SessionInfo }
   | { t: "messages"; sessionId: string; messages: StoredMessage[]; hasMore: boolean; partial?: boolean }
   | { t: "message"; message: StoredMessage; /** text to APPEND for a streamed block that grew (absent