@codyswann/lisa 4.81.2 → 4.81.4

package/plugins/src/base/skills/lisa-session-manager/scripts/token.mjs

@@ -1,7 +1,8 @@
 /**
  * The Telegram bot token the manager needs: validated, stored in
  * `<stateDir>/.env` (dir 0700, file 0600), read from the operator's terminal
- * with echo off, and never put in argv, a return value, an error message or a
+ * with echo off or from the clipboard (`--from-clipboard`, for when no TTY is
+ * reachable), and never put in argv, a return value, an error message or a
  * log line. An existing token is replaced only on request. Split out of
  * launch.mjs, which re-exports everything here.
  * @module token
@@ -10,6 +11,7 @@ import { randomUUID } from "node:crypto";
 import * as nodeFs from "node:fs";
 import path from "node:path";
 
+import { readClipboard } from "./clipboard.mjs";
 import { LaunchError, resolveStateDir } from "./state-dir.mjs";
 
 /** The shape of a BotFather token: `<bot id>:<secret>`. */
@@ -94,41 +96,110 @@ function shellQuote(word) {
  *   input - Script and project locations, and whether to carry `--replace`
  * @returns {string} One shell line
  */
-export function buildStoreTokenCommand({ scriptsDir, projectRoot, replace }) {
+export function buildStoreTokenCommand({
+  scriptsDir,
+  projectRoot,
+  replace,
+  fromClipboard = false,
+}) {
   const script = shellQuote(path.join(scriptsDir, "session-manager.mjs"));
-  const flag = replace ? " --replace" : "";
-  return `node ${script} store-token${flag} --project-root ${shellQuote(projectRoot)}`;
+  const flags =
+    (replace ? " --replace" : "") + (fromClipboard ? " --from-clipboard" : "");
+  return `node ${script} store-token${flags} --project-root ${shellQuote(projectRoot)}`;
+}
+
+/** Why `store-token` cannot prompt here, and the two ways forward. */
+const NO_TTY_HINT =
+  "No terminal to prompt on, and Claude Code's ! prefix has no TTY either. " +
+  "Run `command` in a separate terminal app, or copy the token from " +
+  "BotFather and run `clipboardCommand`.";
+
+/** The `invalid` outcome; names the expected shape, never the input. */
+const INVALID = Object.freeze({
+  stored: false,
+  reason: "invalid",
+  message:
+    "That does not look like a Telegram bot token " +
+    "(expected <digits>:<30 or more letters, digits, _ or ->).",
+});
+
+/**
+ * Refuse to overwrite an existing token unless `replace` was asked for: a
+ * second project that shares this state dir by mistake would otherwise
+ * silently take over the first project's bot.
+ * @param {string} stateDir - Resolved state dir
+ * @param {boolean} replace - `--replace`
+ * @param {{ fs?: { existsSync?: (p: string) => boolean } }} io - Seams
+ */
+function assertReplaceable(stateDir, replace, io) {
+  const existing = path.join(stateDir, TOKEN_FILE_NAME);
+  const exists = io.fs?.existsSync ?? nodeFs.existsSync;
+  if (!replace && exists(existing)) {
+    throw new LaunchError(
+      `A bot token already exists at ${existing}. Nothing was changed. ` +
+        `Re-run store-token with --replace to overwrite it.`
+    );
+  }
+}
+
+/**
+ * Store the bot token from the system clipboard, with no TTY needed.
+ *
+ * Same validation and the same existing-token rule as the prompt. The
+ * clipboard is cleared only after a successful store, so a failed attempt
+ * leaves the operator's copy in place to retry with. The token is never
+ * returned, and an invalid value is reported by shape, never echoed.
+ * @param {{ stateDir: string, replace?: boolean,
+ *   env?: Record<string, string | undefined>, homedir?: string,
+ *   io?: { readClipboard?: typeof readClipboard, fs?: object } }} input -
+ *   Configured state dir, the `--replace` flag and seams
+ * @returns {{ stored: true, path: string, clipboardCleared: boolean } |
+ *   { stored: false, reason: "empty" | "invalid" | "unsupported" |
+ *     "unavailable" | "failed", message: string }} Outcome
+ */
+export function storeTokenFromClipboard(input) {
+  const { replace = false, io = {} } = input;
+  const stateDir = resolveStateDir(input.stateDir, input);
+  assertReplaceable(stateDir, replace, io);
+  const clip = (io.readClipboard ?? readClipboard)();
+  if (!clip.ok) {
+    return { stored: false, reason: clip.reason, message: clip.message };
+  }
+  const token = clip.text.trim();
+  if (!token) {
+    return {
+      stored: false,
+      reason: "empty",
+      message: "The clipboard is empty.",
+    };
+  }
+  if (!validateBotToken(token)) return { ...INVALID };
+  const written = writeTokenFile(stateDir, token, io);
+  return { stored: true, ...written, clipboardCleared: clip.clear() };
 }
 
 /**
  * Prompt for the bot token on the operator's terminal and store it.
  *
- * An existing token is never overwritten without `replace`: a second project
- * that shares this state dir by mistake would otherwise silently take over the
- * first project's bot. With no TTY this does not prompt and does not fail: it
- * returns the exact command for the operator to run themselves, because an
- * agent's Bash can never answer a prompt and a hung setup looks like a slow
- * one.
+ * An existing token is never overwritten without `replace`. With no TTY this
+ * does not prompt and does not fail: it returns the exact command for the
+ * operator to run in a separate terminal app, and the `--from-clipboard` form
+ * of it, because an agent's Bash (and Claude Code's `!` prefix) can never
+ * answer a prompt and a hung setup looks like a slow one.
  * @param {{ stateDir: string, scriptsDir: string, projectRoot: string,
  *   replace?: boolean, env?: Record<string, string | undefined>,
  *   homedir?: string, io?: { canPrompt?: () => boolean,
  *   promptSecret?: (message: string) => string, fs?: object } }} input -
  *   Configured state dir, locations, the `--replace` flag and seams
  * @returns {Promise<{ stored: true, path: string } |
- *   { stored: false, reason: "no-tty", command: string } |
+ *   { stored: false, reason: "no-tty", message: string, command: string,
+ *     clipboardCommand: string } |
  *   { stored: false, reason: "empty" | "invalid", message: string }>} Outcome
  */
 export async function storeToken(input) {
   const { scriptsDir, projectRoot, replace = false, io = {} } = input;
   const stateDir = resolveStateDir(input.stateDir, input);
-  const existing = path.join(stateDir, TOKEN_FILE_NAME);
-  const exists = io.fs?.existsSync ?? nodeFs.existsSync;
-  if (!replace && exists(existing)) {
-    throw new LaunchError(
-      `A bot token already exists at ${existing}. Nothing was changed. ` +
-        `Re-run store-token with --replace to overwrite it.`
-    );
-  }
+  assertReplaceable(stateDir, replace, io);
   const loaded =
     io.canPrompt && io.promptSecret ? null : await loadPromptSecret();
   const canPrompt = io.canPrompt ?? (() => loaded.canPrompt());
@@ -138,7 +209,14 @@ export async function storeToken(input) {
     return {
       stored: false,
       reason: "no-tty",
+      message: NO_TTY_HINT,
       command: buildStoreTokenCommand({ scriptsDir, projectRoot, replace }),
+      clipboardCommand: buildStoreTokenCommand({
+        scriptsDir,
+        projectRoot,
+        replace,
+        fromClipboard: true,
+      }),
     };
   }
   const typed = promptSecret(
@@ -147,15 +225,7 @@ export async function storeToken(input) {
   if (!typed) {
     return { stored: false, reason: "empty", message: "Nothing entered." };
   }
-  if (!validateBotToken(typed)) {
-    return {
-      stored: false,
-      reason: "invalid",
-      message:
-        "That does not look like a Telegram bot token " +
-        "(expected <digits>:<30 or more letters, digits, _ or ->).",
-    };
-  }
+  if (!validateBotToken(typed)) return { ...INVALID };
   return { stored: true, ...writeTokenFile(stateDir, typed, io) };
 }
 

package/plugins/src/base/skills/lisa-setup-session-manager/SKILL.md

@@ -42,11 +42,14 @@ writes `$SM`, and pass `--project-root "$ROOT"` (the absolute project root) on e
 
 1. Preview: `node "$SM/session-manager.mjs" init-config --project-root "$ROOT"`. It detects
    `projects/*/.lisa.config.json` and proposes `name`, `interval`, `repos`, `capacity`, `stall` and a
-   per-project `notify.stateDir`. Show the block to the operator.
+   per-project `notify.stateDir`. Repo detection leaves out linked worktrees and keeps one checkout
+   per remote, so ticket worktrees and second clones under `projects/` are not proposed. Show the
+   block to the operator and ask whether any repo is missing or should not be routed.
 2. Write it: the same command with `--write`. It adds only non-secret fields and never overwrites an
    existing block (`reason: "exists"` means keep it).
-3. Ask the operator to replace each repo's starter `hints` with the technologies and areas that
-   identify it (e.g. `api`: `["NestJS","migrations"]`, `web`: `["Expo","screens"]`), and whether to
+3. Each repo's `hints` are a draft: its name plus one per well-known dependency (`NestJS`, `Expo`,
+   `AWS CDK`, ...). Ask the operator to correct them and add the areas that identify the repo
+   (e.g. `api`: `["NestJS","migrations"]`, `web`: `["Expo","screens"]`), and whether to
    set `sessionManager.trustedAuthorIds`. Without it, any author's Ready item reaches a
    bypass-permissions worker; say so plainly. The list holds stable tracker user ids as strings,
    never logins: the GitHub numeric user id (`gh api users/<login> --jq .id`), the Jira
@@ -61,8 +64,14 @@ The operator creates a bot with @BotFather, one per project. Then run
 - `stored: true`: done.
 - Exit 2 because a token already exists: keep it (re-running setup is safe). Only when the operator
   says the stored token is wrong or belongs to another project, re-run with `store-token --replace`.
-- `reason: "no-tty"` (an agent's Bash has no terminal): print `command` from the output and ask the
-  operator to run it in their own terminal, where it prompts with echo off. Wait for them to confirm.
+- `reason: "no-tty"` (an agent's Bash has no terminal): offer the operator both routes, and say
+  plainly that Claude Code's `!` prefix has no terminal either, so it fails the same way:
+  - **Clipboard (simplest):** they copy the token from the BotFather chat and tell you; then run
+    `clipboardCommand` from the output (`store-token --from-clipboard`). It validates the token,
+    stores it, never prints it, and clears the clipboard. On `stored: false`, say what `message`
+    reports and ask them to copy it again.
+  - **Separate terminal app:** print `command` and ask them to run it in Terminal, iTerm or similar,
+    outside the agent, where it prompts with echo off. Wait for them to confirm.
 - `empty` / `invalid`: say what was wrong and ask again.
 
 Never ask for the token in chat, never echo, log or commit it, and never put it in
@@ -97,14 +106,24 @@ If `.lisa/automations/session-manager.runbook.md` does not exist, copy
 `$SM/../references/runbook-template.md` there. Never overwrite an existing runbook: it is the
 project's. It is checked in, like every automation runbook (`automation-runbook-contract`).
 
-## Step 7: Coexistence warning
-
-Tell the operator, before starting: if this project also runs the scheduled `intake-repair` loop, it
-can re-dispatch an item a local worker is still building (it treats a claimed item with no tracker
-activity for `intake.repair.staleAfterHours` as stalled). `intake-tickets` competes for the same
-Ready items. Recommend tearing down `intake-tickets` (`/lisa:tear-down-automations intake-tickets`)
-and either raising `intake.repair.staleAfterHours` above `stall.noOutputMinutes × stall.maxAttempts`
-or tearing down `intake-repair`.
+## Step 7: Check for competing intake loops
+
+The scheduled `intake-repair` loop can re-dispatch an item a local worker is still building (it treats
+a claimed item with no tracker activity for `intake.repair.staleAfterHours` as stalled), and
+`intake-tickets` competes for the same Ready items. Find out whether either is running before you
+start the manager; do not leave the operator to check.
+
+1. Run `node "$SM/session-manager.mjs" coexistence --project-root "$ROOT"`. For each loop it reports
+   the last run recorded in this project's run log and whether that is `recent`. `live` lists the
+   loops that ran recently.
+2. A run log is evidence, not proof: also list your runtime's scheduler for those loop names (Claude
+   Code: the `/schedule` listing of claude.ai routines; Codex: automations; a `lisa-<loop>.yml`
+   workflow with a `schedule:` trigger on GitHub Actions).
+3. Report what you found, per loop, in one line each. Only for a loop that is live (a recent run, or a
+   scheduler entry): recommend tearing down `intake-tickets` (`/lisa:tear-down-automations
+   intake-tickets`) and either raising `intake.repair.staleAfterHours` above
+   `stall.noOutputMinutes × stall.maxAttempts` or tearing down `intake-repair`. When neither is live,
+   say so and move on.
 
 ## Step 8: Accept workspace trust in each worker repo
 
@@ -113,12 +132,15 @@ folder?" prompt: until someone has accepted it in a directory, `claude --bg` ref
 and `spawn` exits 2 saying so. Do this once per routed repo (or once for the root on a single-repo
 project), on every machine that runs the manager:
 
-1. List the directories workers start in. Single-repo: the project root. Multi-repo: for each key in
-   `sessionManager.repos.entries`,
-   `node "$SM/session-manager.mjs" repo-dir --repo <key> --raw --project-root "$ROOT"`.
-2. Ask the operator, in their own terminal, to run `claude` once in that directory,
-   accept the trust prompt, then exit. An agent's Bash cannot answer that prompt, so never try to
-   accept it for them.
+1. Run `node "$SM/session-manager.mjs" trust-status --project-root "$ROOT"`. It lists every
+   directory workers start in (each routed repo, or the root on a single-repo project) with whether
+   Claude Code has already recorded trust for it. `needsTrust` lists the ones that are not
+   `trusted: true`. When it is empty, this step is done: say so.
+2. For each directory in `needsTrust`, ask the operator, in a separate terminal app (not the agent's
+   Bash or Claude Code's `!` prefix), to run `claude` once in that directory, accept the trust prompt,
+   then exit. An agent's Bash cannot answer that prompt, so never try to accept it for them. Then
+   re-run `trust-status` to confirm. (`trusted: "unknown"` means Claude Code's state file could not be
+   read; treat it as needing trust.)
 3. Re-run this step whenever a repo is added to `sessionManager.repos`.
 
 ## Step 9: Start and pair
@@ -152,5 +174,6 @@ confirm the "Session manager Telegram isolation?" check is green. Fix every warn
 `node "$SM/session-manager.mjs" status --project-root "$ROOT"` should show the manager running.
 
 Report: the config block written (or kept), where the token lives (the path, never the value), the
-plugin scope result, the runbook path, which repo dirs had workspace trust accepted, the manager's
-tmux session name, and the doctor result.
+plugin scope result, the runbook path, which repo dirs were already trusted and which the operator
+accepted trust in, what the competing-loop check found, the manager's tmux session name, and the
+doctor result.