Compare commits
1 Commits
006b7352c7
...
feat/mosai
| Author | SHA1 | Date | |
|---|---|---|---|
|
ad3f6ae042 |
@@ -1,193 +0,0 @@
|
||||
# Gateway Admin Token Recovery — Implementation Plan
|
||||
|
||||
**Mission:** `cli-unification-20260404`
|
||||
**Task:** `CU-03-01` (planning only — no runtime code changes)
|
||||
**Status:** Design locked (Session 1) — BetterAuth cookie-based recovery
|
||||
|
||||
---
|
||||
|
||||
## 1. Problem Statement
|
||||
|
||||
The gateway installer strands operators when the admin user exists but the admin
|
||||
API token is missing. Concrete trigger:
|
||||
|
||||
- `~/.config/mosaic/gateway/meta.json` was deleted / regenerated.
|
||||
- The installer was re-run after a previous successful bootstrap.
|
||||
|
||||
Flow today (`packages/mosaic/src/commands/gateway/install.ts:375-400`):
|
||||
|
||||
1. `bootstrapFirstUser` hits `GET /api/bootstrap/status`.
|
||||
2. Server returns `needsSetup: false` because `users` count > 0.
|
||||
3. Installer logs `Admin user already exists — skipping setup. (No admin token on file — sign in via the web UI to manage tokens.)` and returns.
|
||||
4. The operator now has:
|
||||
- No token in `meta.json`.
|
||||
- No CLI path to mint a new one (`mosaic gateway <anything>` that needs the token fails).
|
||||
- `POST /api/bootstrap/setup` locked out — it only runs when `users` count is zero (`apps/gateway/src/admin/bootstrap.controller.ts:34-37`).
|
||||
- `POST /api/admin/tokens` gated by `AdminGuard` — requires either a bearer token (which they don't have) or a BetterAuth session (which they don't have in the CLI).
|
||||
|
||||
Dead end. The web UI is the only escape hatch today, and for headless installs even that may be inaccessible.
|
||||
|
||||
## 2. Design Summary
|
||||
|
||||
The BetterAuth session cookie is the authority. The operator runs
|
||||
`mosaic gateway login` to sign in with email/password, which persists a session
|
||||
cookie via `saveSession` (reusing `packages/mosaic/src/auth.ts`). With a valid
|
||||
session, `mosaic gateway config recover-token` (stranded-operator entry point)
|
||||
and `mosaic gateway config rotate-token` call the existing authenticated admin
|
||||
endpoint `POST /api/admin/tokens` using the cookie, then persist the returned
|
||||
plaintext to `meta.json` via `writeMeta`. **No new server endpoints are
|
||||
required** — `AdminGuard` already accepts BetterAuth session cookies via its
|
||||
`validateSession` path (`apps/gateway/src/admin/admin.guard.ts:90-120`).
|
||||
|
||||
## 3. Surface Contract
|
||||
|
||||
### 3.1 Server — no changes required
|
||||
|
||||
| Endpoint | Status | Notes |
|
||||
| ------------------------------ | --------------- | ------------------------------------------------------------------------------------------------------------------------ |
|
||||
| `POST /api/admin/tokens` | **Reuse as-is** | `admin-tokens.controller.ts:46-72`. Returns `{ id, label, scope, expiresAt, lastUsedAt, createdAt, plaintext }`. |
|
||||
| `GET /api/admin/tokens` | **Reuse** | Useful for `mosaic gateway config tokens list` follow-on (out of scope for CU-03-01, but trivial once auth path exists). |
|
||||
| `DELETE /api/admin/tokens/:id` | **Reuse** | Used by rotate flow for optional old-token revocation. |
|
||||
| `POST /api/bootstrap/setup` | **Unchanged** | Remains first-user-only; not part of recovery. |
|
||||
|
||||
`AdminGuard.validateSession` takes BetterAuth cookies from `request.raw.headers`
|
||||
via `fromNodeHeaders` and calls `auth.api.getSession({ headers })`. It also
|
||||
enforces `role === 'admin'`. This is exactly the path the CLI will hit with
|
||||
`Cookie: better-auth.session_token=...`.
|
||||
|
||||
**Confirmed feasible** during CU-03-01 investigation.
|
||||
|
||||
### 3.2 `mosaic gateway login`
|
||||
|
||||
Thin wrapper over the existing top-level `mosaic login`
|
||||
(`packages/mosaic/src/cli.ts:42-76`) with gateway-specific defaults pulled from
|
||||
`readMeta()`.
|
||||
|
||||
| Aspect | Behavior |
|
||||
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| Default gateway URL | `http://${meta.host}:${meta.port}` from `readMeta()`, fallback `http://localhost:14242`. |
|
||||
| Flow | Prompt email + password -> `signIn()` -> `saveSession()`. |
|
||||
| Persistence | `~/.mosaic/session.json` via existing `saveSession` (7-day expiry). |
|
||||
| Decision | **Thin wrapper**, not alias. Rationale: defaults differ (reads `meta.json`), and discoverability under `mosaic gateway --help`. |
|
||||
| Implementation | Share the sign-in logic by extracting a small `runLogin(gatewayUrl, email?, password?)` helper; both commands call it. |
|
||||
|
||||
### 3.3 `mosaic gateway config rotate-token`
|
||||
|
||||
| Aspect | Behavior |
|
||||
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| Precondition | Valid session (via `loadSession` + `validateSession`). On failure, print: "Not signed in — run `mosaic gateway login`" and exit non-zero. |
|
||||
| Request | `POST ${gatewayUrl}/api/admin/tokens` with header `Cookie: <session>`, body `{ label: "CLI token (rotated YYYY-MM-DD)" }`. |
|
||||
| On success | Read meta via `readMeta()`, set `meta.adminToken = plaintext`, `writeMeta(meta)`. Print the token banner (reuse `printAdminTokenBanner` shape). |
|
||||
| Old token | **Optional `--revoke-old`** flag. When set and a previous `meta.adminToken` existed, call `DELETE /api/admin/tokens/:id` after rotation. Requires listing first to find the id; punt to CU-03-02 decision. Document as nice-to-have. |
|
||||
| Exit codes | `0` success; `1` network error; `2` auth error; `3` server rejection. |
|
||||
|
||||
### 3.4 `mosaic gateway config recover-token`
|
||||
|
||||
Superset of `rotate-token` with an inline login nudge — the "stranded operator"
|
||||
entry point.
|
||||
|
||||
| Step | Action |
|
||||
| ---- | -------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| 1 | `readMeta()` — derive gateway URL. If meta is missing entirely, fall back to `--gateway` flag or default. |
|
||||
| 2 | `loadSession(gatewayUrl)` then `validateSession`. If either fails, prompt inline: email + password -> `signIn` -> `saveSession`. |
|
||||
| 3 | `POST /api/admin/tokens` with cookie, label `"Recovered via CLI YYYY-MM-DDTHH:mm"`. |
|
||||
| 4 | Persist plaintext to `meta.json` via `writeMeta`. |
|
||||
| 5 | Print the token banner and next-steps hints (e.g. `mosaic gateway status`). |
|
||||
| 6 | Exit `0`. |
|
||||
|
||||
Key property: this command is **runnable with nothing but email+password in hand**.
|
||||
It assumes the gateway is up but assumes no prior CLI session state.
|
||||
|
||||
### 3.5 File touch list (for CU-03-02..05 execution)
|
||||
|
||||
| File | Change |
|
||||
| ----------------------------------------------------- | ------------------------------------------------------------------------------------------ |
|
||||
| `packages/mosaic/src/commands/gateway.ts` | Register `login`, `config recover-token`, `config rotate-token` subcommands under `gw`. |
|
||||
| `packages/mosaic/src/commands/gateway/config.ts` | Add `runRecoverToken`, `runRotateToken` handlers; export from module. |
|
||||
| `packages/mosaic/src/commands/gateway/login.ts` (new) | Thin wrapper calling shared `runLogin` helper with meta-derived default URL. |
|
||||
| `packages/mosaic/src/auth.ts` | No change expected. Possibly export a `requireSession(gatewayUrl)` helper (reuse pattern). |
|
||||
| `packages/mosaic/src/commands/gateway/install.ts` | `bootstrapFirstUser` branch: "user exists, no token" -> offer recovery (see Section 4). |
|
||||
|
||||
## 4. Installer Fix (CU-03-06 preview)
|
||||
|
||||
Current stranding point is `install.ts:388-395`. The fix:
|
||||
|
||||
```
|
||||
if (!status.needsSetup) {
|
||||
if (meta.adminToken) {
|
||||
// unchanged — happy path
|
||||
} else {
|
||||
// NEW: prompt "Admin exists but no token on file. Recover now? [Y/n]"
|
||||
// If yes -> call runRecoverToken(gatewayUrl) inline (interactive):
|
||||
// - prompt email + password
|
||||
// - signIn -> saveSession
|
||||
// - POST /api/admin/tokens
|
||||
// - writeMeta(meta) with returned plaintext
|
||||
// - print banner
|
||||
// If no -> print the current stranded message but include:
|
||||
// "Run `mosaic gateway config recover-token` when ready."
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Shape notes (actual code lands in CU-03-06):
|
||||
|
||||
- Extract the recovery body so it can be called **both** from the standalone
|
||||
command and from `bootstrapFirstUser` without duplicating prompts.
|
||||
- Reuse the same `rl` readline interface already open in `bootstrapFirstUser`
|
||||
for the inline prompts.
|
||||
- Preserve non-interactive behavior: if `process.stdin.isTTY` is false, skip the
|
||||
prompt and emit the "run recover-token" hint only.
|
||||
|
||||
## 5. Test Strategy (CU-03-07 scope)
|
||||
|
||||
### 5.1 Happy paths
|
||||
|
||||
| Command | Scenario | Expected |
|
||||
| ------------------------------------- | ------------------------------------------------ | -------------------------------------------------------- |
|
||||
| `mosaic gateway login` | Valid creds | `session.json` written, 7-day expiry, exit 0 |
|
||||
| `mosaic gateway config rotate-token` | Valid session, server reachable | `meta.json` updated, banner printed, new token usable |
|
||||
| `mosaic gateway config recover-token` | No session, valid creds, server reachable | Prompts for creds, writes session + meta, exit 0 |
|
||||
| Installer inline recovery | Re-run after `meta.json` wipe, operator says yes | Meta restored, banner printed, no manual CLI step needed |
|
||||
|
||||
### 5.2 Error paths (must all produce actionable messages and non-zero exit)
|
||||
|
||||
| Failure | Expected handling |
|
||||
| --------------------------------- | --------------------------------------------------------------------------------- |
|
||||
| Invalid email/password | BetterAuth 401 surfaced as "Sign-in failed: <server message>", exit 2 |
|
||||
| Expired stored session | Recover command silently re-prompts; rotate command exits 2 with "run login" hint |
|
||||
| Gateway down / connection refused | "Could not reach gateway at <url>" exit 1 |
|
||||
| Server rejects token creation | Print status + body excerpt, exit 3 |
|
||||
| Meta file missing (recover) | Fall back to `--gateway` flag or default; warn that meta will be created |
|
||||
| Non-admin user | `AdminGuard` 403 surfaced as "User is not an admin", exit 2 |
|
||||
|
||||
### 5.3 Integration test (recommended)
|
||||
|
||||
Spin up gateway in test harness, create admin user via `/api/bootstrap/setup`,
|
||||
wipe `meta.json`, invoke `mosaic gateway config recover-token` programmatically,
|
||||
assert new `meta.adminToken` works against `GET /api/admin/tokens`.
|
||||
|
||||
## 6. Risks & Open Questions
|
||||
|
||||
| # | Item | Severity | Mitigation |
|
||||
| --- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------- |
|
||||
| 1 | `AdminGuard.validateSession` calls `getSession` with `fromNodeHeaders(request.raw.headers)`. CLI sends `Cookie:` header only. Confirm BetterAuth reads from `Cookie`, not `Set-Cookie`. | Low | Confirmed — `mosaic login` + `mosaic tui` already use this flow successfully (`cli.ts:137-181`). |
|
||||
| 2 | Session cookie local expiry (7d) vs BetterAuth server-side expiry may drift. | Low | `validateSession` hits `get-session`; handle 401 by re-prompting. |
|
||||
| 3 | Label collision / unbounded token growth if operators run `recover-token` repeatedly. | Low | Include ISO timestamp in label. Optional `--revoke-old` in CU-03-02. Add `tokens list/prune` later. |
|
||||
| 4 | `mosaic login` exists at top level and `mosaic gateway login` is a wrapper — risk of confusion. | Low | Document that `gateway login` is the preferred entry for gateway operators; top-level stays for compatibility. |
|
||||
| 5 | `meta.json` write is not atomic. Crash between token creation and `writeMeta` leaves an orphan token server-side with no plaintext on disk. | Medium | Accept for now — re-running `recover-token` mints a fresh token. Document as known limitation. |
|
||||
| 6 | Non-TTY installer runs (CI, headless provisioners) cannot prompt for creds interactively. | Medium | Installer inline recovery must skip prompt when `!process.stdin.isTTY`; emit the recover-token hint. |
|
||||
| 7 | If `BETTER_AUTH_SECRET` rotates between login and recover, the session cookie is invalid — user must re-login. Acceptable but surface a clear error. | Low | Error handler maps 401 on recover -> "Session invalid; re-run `mosaic gateway login`". |
|
||||
| 8 | No MFA today. When MFA lands, BetterAuth sign-in will return a challenge, not a cookie — recovery UX will need a second prompt step. | Future | Out of scope for this mission. Flag for future CLI work. |
|
||||
|
||||
## 7. Downstream Task Hooks
|
||||
|
||||
| Task | Scope |
|
||||
| -------- | -------------------------------------------------------------------------- |
|
||||
| CU-03-02 | Implement `mosaic gateway login` wrapper + shared `runLogin` extraction. |
|
||||
| CU-03-03 | Implement `mosaic gateway config rotate-token`. |
|
||||
| CU-03-04 | Implement `mosaic gateway config recover-token`. |
|
||||
| CU-03-05 | Wire commands into `gateway.ts` registration, update `--help` copy. |
|
||||
| CU-03-06 | Installer inline recovery hook in `bootstrapFirstUser`. |
|
||||
| CU-03-07 | Tests per Section 5. |
|
||||
| CU-03-08 | Docs: update gateway install README + operator runbook with recovery flow. |
|
||||
@@ -26,8 +26,7 @@
|
||||
"test": "vitest run --passWithNoTests"
|
||||
},
|
||||
"dependencies": {
|
||||
"@mosaicstack/macp": "workspace:*",
|
||||
"commander": "^13.0.0"
|
||||
"@mosaicstack/macp": "workspace:*"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.0.0",
|
||||
|
||||
@@ -1,57 +0,0 @@
|
||||
import { Command } from 'commander';
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { registerForgeCommand } from './cli.js';
|
||||
|
||||
describe('registerForgeCommand', () => {
|
||||
it('registers a "forge" command on the parent program', () => {
|
||||
const program = new Command();
|
||||
registerForgeCommand(program);
|
||||
|
||||
const forgeCmd = program.commands.find((c) => c.name() === 'forge');
|
||||
expect(forgeCmd).toBeDefined();
|
||||
});
|
||||
|
||||
it('registers the four required subcommands under forge', () => {
|
||||
const program = new Command();
|
||||
registerForgeCommand(program);
|
||||
|
||||
const forgeCmd = program.commands.find((c) => c.name() === 'forge');
|
||||
expect(forgeCmd).toBeDefined();
|
||||
|
||||
const subNames = forgeCmd!.commands.map((c) => c.name());
|
||||
|
||||
expect(subNames).toContain('run');
|
||||
expect(subNames).toContain('status');
|
||||
expect(subNames).toContain('resume');
|
||||
expect(subNames).toContain('personas');
|
||||
});
|
||||
|
||||
it('registers "personas list" as a subcommand of "forge personas"', () => {
|
||||
const program = new Command();
|
||||
registerForgeCommand(program);
|
||||
|
||||
const forgeCmd = program.commands.find((c) => c.name() === 'forge');
|
||||
const personasCmd = forgeCmd!.commands.find((c) => c.name() === 'personas');
|
||||
expect(personasCmd).toBeDefined();
|
||||
|
||||
const personasSubNames = personasCmd!.commands.map((c) => c.name());
|
||||
expect(personasSubNames).toContain('list');
|
||||
});
|
||||
|
||||
it('does not modify the parent program name or description', () => {
|
||||
const program = new Command('mosaic');
|
||||
program.description('Mosaic Stack CLI');
|
||||
registerForgeCommand(program);
|
||||
|
||||
expect(program.name()).toBe('mosaic');
|
||||
expect(program.description()).toBe('Mosaic Stack CLI');
|
||||
});
|
||||
|
||||
it('can be called multiple times without throwing', () => {
|
||||
const program = new Command();
|
||||
expect(() => {
|
||||
registerForgeCommand(program);
|
||||
}).not.toThrow();
|
||||
});
|
||||
});
|
||||
@@ -1,280 +0,0 @@
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
import type { Command } from 'commander';
|
||||
|
||||
import { classifyBrief } from './brief-classifier.js';
|
||||
import { STAGE_LABELS, STAGE_SEQUENCE } from './constants.js';
|
||||
import { getEffectivePersonas, loadBoardPersonas } from './persona-loader.js';
|
||||
import { generateRunId, getPipelineStatus, loadManifest, runPipeline } from './pipeline-runner.js';
|
||||
import type { PipelineOptions, RunManifest, TaskExecutor } from './types.js';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Stub executor — used when no real executor is wired at CLI invocation time.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const stubExecutor: TaskExecutor = {
|
||||
async submitTask(task) {
|
||||
console.log(` [forge] stage submitted: ${task.id} (${task.title})`);
|
||||
},
|
||||
async waitForCompletion(taskId, _timeoutMs) {
|
||||
console.log(` [forge] stage complete: ${taskId}`);
|
||||
return {
|
||||
task_id: taskId,
|
||||
status: 'completed' as const,
|
||||
completed_at: new Date().toISOString(),
|
||||
exit_code: 0,
|
||||
gate_results: [],
|
||||
};
|
||||
},
|
||||
async getTaskStatus(_taskId) {
|
||||
return 'completed' as const;
|
||||
},
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function formatDuration(startedAt?: string, completedAt?: string): string {
|
||||
if (!startedAt || !completedAt) return '-';
|
||||
const ms = new Date(completedAt).getTime() - new Date(startedAt).getTime();
|
||||
const secs = Math.round(ms / 1000);
|
||||
return secs < 60 ? `${secs}s` : `${Math.floor(secs / 60)}m${secs % 60}s`;
|
||||
}
|
||||
|
||||
function printManifestTable(manifest: RunManifest): void {
|
||||
console.log(`\nRun ID : ${manifest.runId}`);
|
||||
console.log(`Status : ${manifest.status}`);
|
||||
console.log(`Brief : ${manifest.brief}`);
|
||||
console.log(`Class : ${manifest.briefClass} (${manifest.classSource})`);
|
||||
console.log(`Updated: ${manifest.updatedAt}`);
|
||||
console.log('');
|
||||
console.log('Stage'.padEnd(22) + 'Status'.padEnd(14) + 'Duration');
|
||||
console.log('-'.repeat(50));
|
||||
for (const stage of STAGE_SEQUENCE) {
|
||||
const s = manifest.stages[stage];
|
||||
if (!s) continue;
|
||||
const label = (STAGE_LABELS[stage] ?? stage).padEnd(22);
|
||||
const status = s.status.padEnd(14);
|
||||
const dur = formatDuration(s.startedAt, s.completedAt);
|
||||
console.log(`${label}${status}${dur}`);
|
||||
}
|
||||
console.log('');
|
||||
}
|
||||
|
||||
function resolveRunDir(runId: string, projectRoot?: string): string {
|
||||
const root = projectRoot ?? process.cwd();
|
||||
return path.join(root, '.forge', 'runs', runId);
|
||||
}
|
||||
|
||||
function listRecentRuns(projectRoot?: string): void {
|
||||
const root = projectRoot ?? process.cwd();
|
||||
const runsDir = path.join(root, '.forge', 'runs');
|
||||
|
||||
if (!fs.existsSync(runsDir)) {
|
||||
console.log('No runs found. Run `mosaic forge run` to start a pipeline.');
|
||||
return;
|
||||
}
|
||||
|
||||
const entries = fs
|
||||
.readdirSync(runsDir)
|
||||
.filter((name) => fs.statSync(path.join(runsDir, name)).isDirectory())
|
||||
.sort()
|
||||
.reverse()
|
||||
.slice(0, 10);
|
||||
|
||||
if (entries.length === 0) {
|
||||
console.log('No runs found.');
|
||||
return;
|
||||
}
|
||||
|
||||
console.log('\nRecent runs:');
|
||||
console.log('Run ID'.padEnd(22) + 'Status'.padEnd(14) + 'Brief');
|
||||
console.log('-'.repeat(70));
|
||||
|
||||
for (const runId of entries) {
|
||||
const runDir = path.join(runsDir, runId);
|
||||
try {
|
||||
const manifest = loadManifest(runDir);
|
||||
const status = manifest.status.padEnd(14);
|
||||
const brief = path.basename(manifest.brief);
|
||||
console.log(`${runId.padEnd(22)}${status}${brief}`);
|
||||
} catch {
|
||||
console.log(`${runId.padEnd(22)}${'(unreadable)'.padEnd(14)}`);
|
||||
}
|
||||
}
|
||||
console.log('');
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Register function
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Register forge subcommands on an existing Commander program.
|
||||
* Mirrors the pattern used by registerQualityRails in @mosaicstack/quality-rails.
|
||||
*/
|
||||
export function registerForgeCommand(parent: Command): void {
|
||||
const forge = parent.command('forge').description('Run and manage Forge pipelines');
|
||||
|
||||
// ── forge run ────────────────────────────────────────────────────────────
|
||||
|
||||
forge
|
||||
.command('run')
|
||||
.description('Run a Forge pipeline from a brief markdown file')
|
||||
.requiredOption('--brief <path>', 'Path to the brief markdown file')
|
||||
.option('--run-id <id>', 'Override the auto-generated run ID')
|
||||
.option('--resume', 'Resume an existing run instead of starting a new one', false)
|
||||
.option('--config <path>', 'Path to forge config file (.forge/config.yaml)')
|
||||
.option('--codebase <path>', 'Codebase root to pass to the pipeline', process.cwd())
|
||||
.option('--dry-run', 'Print planned stages without executing', false)
|
||||
.action(
|
||||
async (opts: {
|
||||
brief: string;
|
||||
runId?: string;
|
||||
resume: boolean;
|
||||
config?: string;
|
||||
codebase: string;
|
||||
dryRun: boolean;
|
||||
}) => {
|
||||
const briefPath = path.resolve(opts.brief);
|
||||
|
||||
if (!fs.existsSync(briefPath)) {
|
||||
console.error(`[forge] brief not found: ${briefPath}`);
|
||||
process.exitCode = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
const briefContent = fs.readFileSync(briefPath, 'utf-8');
|
||||
const briefClass = classifyBrief(briefContent);
|
||||
const projectRoot = opts.codebase;
|
||||
|
||||
if (opts.resume) {
|
||||
const runId = opts.runId ?? generateRunId();
|
||||
const runDir = resolveRunDir(runId, projectRoot);
|
||||
console.log(`[forge] resuming run: ${runId}`);
|
||||
const { resumePipeline } = await import('./pipeline-runner.js');
|
||||
const result = await resumePipeline(runDir, stubExecutor);
|
||||
console.log(`[forge] pipeline complete: ${result.runId}`);
|
||||
return;
|
||||
}
|
||||
|
||||
const pipelineOptions: PipelineOptions = {
|
||||
briefClass,
|
||||
codebase: projectRoot,
|
||||
dryRun: opts.dryRun,
|
||||
executor: stubExecutor,
|
||||
};
|
||||
|
||||
if (opts.dryRun) {
|
||||
const { stagesForClass } = await import('./brief-classifier.js');
|
||||
const stages = stagesForClass(briefClass);
|
||||
console.log(`[forge] dry-run — brief class: ${briefClass}`);
|
||||
console.log('[forge] planned stages:');
|
||||
for (const stage of stages) {
|
||||
console.log(` - ${stage} (${STAGE_LABELS[stage] ?? stage})`);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`[forge] starting pipeline for brief: ${briefPath}`);
|
||||
console.log(`[forge] classified as: ${briefClass}`);
|
||||
|
||||
try {
|
||||
const result = await runPipeline(briefPath, projectRoot, pipelineOptions);
|
||||
console.log(`[forge] pipeline complete: ${result.runId}`);
|
||||
console.log(`[forge] run directory: ${result.runDir}`);
|
||||
} catch (err) {
|
||||
console.error(
|
||||
`[forge] pipeline failed: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
process.exitCode = 1;
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
// ── forge status ─────────────────────────────────────────────────────────
|
||||
|
||||
forge
|
||||
.command('status [runId]')
|
||||
.description('Show the status of a pipeline run (omit runId to list recent runs)')
|
||||
.option('--project <path>', 'Project root (defaults to cwd)', process.cwd())
|
||||
.action(async (runId: string | undefined, opts: { project: string }) => {
|
||||
if (!runId) {
|
||||
listRecentRuns(opts.project);
|
||||
return;
|
||||
}
|
||||
|
||||
const runDir = resolveRunDir(runId, opts.project);
|
||||
try {
|
||||
const manifest = getPipelineStatus(runDir);
|
||||
printManifestTable(manifest);
|
||||
} catch (err) {
|
||||
console.error(
|
||||
`[forge] could not load run "${runId}": ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
process.exitCode = 1;
|
||||
}
|
||||
});
|
||||
|
||||
// ── forge resume ─────────────────────────────────────────────────────────
|
||||
|
||||
forge
|
||||
.command('resume <runId>')
|
||||
.description('Resume a stopped or failed pipeline run')
|
||||
.option('--project <path>', 'Project root (defaults to cwd)', process.cwd())
|
||||
.action(async (runId: string, opts: { project: string }) => {
|
||||
const runDir = resolveRunDir(runId, opts.project);
|
||||
|
||||
if (!fs.existsSync(runDir)) {
|
||||
console.error(`[forge] run not found: ${runDir}`);
|
||||
process.exitCode = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`[forge] resuming run: ${runId}`);
|
||||
|
||||
try {
|
||||
const { resumePipeline } = await import('./pipeline-runner.js');
|
||||
const result = await resumePipeline(runDir, stubExecutor);
|
||||
console.log(`[forge] pipeline complete: ${result.runId}`);
|
||||
console.log(`[forge] run directory: ${result.runDir}`);
|
||||
} catch (err) {
|
||||
console.error(`[forge] resume failed: ${err instanceof Error ? err.message : String(err)}`);
|
||||
process.exitCode = 1;
|
||||
}
|
||||
});
|
||||
|
||||
// ── forge personas ────────────────────────────────────────────────────────
|
||||
|
||||
const personas = forge.command('personas').description('Manage Forge board personas');
|
||||
|
||||
personas
|
||||
.command('list')
|
||||
.description('List configured board personas')
|
||||
.option(
|
||||
'--project <path>',
|
||||
'Project root for persona overrides (defaults to cwd)',
|
||||
process.cwd(),
|
||||
)
|
||||
.option('--board-dir <path>', 'Override the board agents directory')
|
||||
.action((opts: { project: string; boardDir?: string }) => {
|
||||
const effectivePersonas = opts.boardDir
|
||||
? loadBoardPersonas(opts.boardDir)
|
||||
: getEffectivePersonas(opts.project);
|
||||
|
||||
if (effectivePersonas.length === 0) {
|
||||
console.log('[forge] no board personas configured.');
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`\nBoard personas (${effectivePersonas.length}):\n`);
|
||||
console.log('Slug'.padEnd(24) + 'Name');
|
||||
console.log('-'.repeat(50));
|
||||
for (const p of effectivePersonas) {
|
||||
console.log(`${p.slug.padEnd(24)}${p.name}`);
|
||||
}
|
||||
console.log('');
|
||||
});
|
||||
}
|
||||
@@ -80,6 +80,3 @@ export {
|
||||
resumePipeline,
|
||||
getPipelineStatus,
|
||||
} from './pipeline-runner.js';
|
||||
|
||||
// CLI
|
||||
export { registerForgeCommand } from './cli.js';
|
||||
|
||||
@@ -33,7 +33,6 @@
|
||||
"@mosaicstack/macp": "workspace:*",
|
||||
"@mosaicstack/prdy": "workspace:*",
|
||||
"@mosaicstack/quality-rails": "workspace:*",
|
||||
"@mosaicstack/queue": "workspace:*",
|
||||
"@mosaicstack/types": "workspace:*",
|
||||
"@clack/prompts": "^0.9.1",
|
||||
"commander": "^13.0.0",
|
||||
|
||||
@@ -3,11 +3,8 @@
|
||||
import { createRequire } from 'module';
|
||||
import { Command } from 'commander';
|
||||
import { registerBrainCommand } from '@mosaicstack/brain';
|
||||
import { registerForgeCommand } from '@mosaicstack/forge';
|
||||
import { registerQualityRails } from '@mosaicstack/quality-rails';
|
||||
import { registerQueueCommand } from '@mosaicstack/queue';
|
||||
import { registerAgentCommand } from './commands/agent.js';
|
||||
import { registerConfigCommand } from './commands/config.js';
|
||||
import { registerMissionCommand } from './commands/mission.js';
|
||||
// prdy is registered via launch.ts
|
||||
import { registerLaunchCommands } from './commands/launch.js';
|
||||
@@ -37,23 +34,7 @@ try {
|
||||
|
||||
const program = new Command();
|
||||
|
||||
program
|
||||
.name('mosaic')
|
||||
.description('Mosaic Stack CLI')
|
||||
.version(CLI_VERSION)
|
||||
.configureHelp({ sortSubcommands: true })
|
||||
.addHelpText(
|
||||
'after',
|
||||
`
|
||||
Command Groups:
|
||||
|
||||
Runtime: tui, login, sessions
|
||||
Gateway: gateway
|
||||
Framework: agent, bootstrap, coord, doctor, init, launch, mission, prdy, seq, sync, upgrade, wizard, yolo
|
||||
Platform: update
|
||||
Runtimes: claude, codex, opencode, pi
|
||||
`,
|
||||
);
|
||||
program.name('mosaic').description('Mosaic Stack CLI').version(CLI_VERSION);
|
||||
|
||||
// ─── runtime launchers + framework commands ────────────────────────────
|
||||
|
||||
@@ -234,10 +215,7 @@ program
|
||||
|
||||
// ─── sessions ───────────────────────────────────────────────────────────
|
||||
|
||||
const sessionsCmd = program
|
||||
.command('sessions')
|
||||
.description('Manage active agent sessions')
|
||||
.configureHelp({ sortSubcommands: true });
|
||||
const sessionsCmd = program.command('sessions').description('Manage active agent sessions');
|
||||
|
||||
sessionsCmd
|
||||
.command('list')
|
||||
@@ -333,10 +311,6 @@ registerGatewayCommand(program);
|
||||
|
||||
registerAgentCommand(program);
|
||||
|
||||
// ─── config ────────────────────────────────────────────────────────────
|
||||
|
||||
registerConfigCommand(program);
|
||||
|
||||
// ─── mission ───────────────────────────────────────────────────────────
|
||||
|
||||
registerMissionCommand(program);
|
||||
@@ -345,18 +319,10 @@ registerMissionCommand(program);
|
||||
|
||||
registerBrainCommand(program);
|
||||
|
||||
// ─── forge ───────────────────────────────────────────────────────────────
|
||||
|
||||
registerForgeCommand(program);
|
||||
|
||||
// ─── quality-rails ──────────────────────────────────────────────────────
|
||||
|
||||
registerQualityRails(program);
|
||||
|
||||
// ─── queue ───────────────────────────────────────────────────────────────
|
||||
|
||||
registerQueueCommand(program);
|
||||
|
||||
// ─── update ─────────────────────────────────────────────────────────────
|
||||
|
||||
program
|
||||
|
||||
@@ -1,289 +0,0 @@
|
||||
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
||||
import { Command } from 'commander';
|
||||
import { registerConfigCommand } from './config.js';
|
||||
|
||||
// ── helpers ──────────────────────────────────────────────────────────────────
|
||||
|
||||
/** Build a fresh Command tree with the config command registered. */
|
||||
function buildProgram(): Command {
|
||||
const program = new Command();
|
||||
program.exitOverride(); // prevent process.exit during tests
|
||||
registerConfigCommand(program);
|
||||
return program;
|
||||
}
|
||||
|
||||
/** Locate the 'config' command registered on the root program. */
|
||||
function getConfigCmd(program: Command): Command {
|
||||
const found = program.commands.find((c) => c.name() === 'config');
|
||||
if (!found) throw new Error('config command not found');
|
||||
return found;
|
||||
}
|
||||
|
||||
// ── subcommand registration ───────────────────────────────────────────────────
|
||||
|
||||
describe('registerConfigCommand', () => {
|
||||
it('registers a "config" command on the program', () => {
|
||||
const program = buildProgram();
|
||||
const names = program.commands.map((c) => c.name());
|
||||
expect(names).toContain('config');
|
||||
});
|
||||
|
||||
it('registers exactly the five required subcommands', () => {
|
||||
const program = buildProgram();
|
||||
const config = getConfigCmd(program);
|
||||
const subs = config.commands.map((c) => c.name()).sort();
|
||||
expect(subs).toEqual(['edit', 'get', 'path', 'set', 'show']);
|
||||
});
|
||||
});
|
||||
|
||||
// ── mock config service ───────────────────────────────────────────────────────
|
||||
|
||||
const mockSoul = {
|
||||
agentName: 'TestBot',
|
||||
roleDescription: 'test role',
|
||||
communicationStyle: 'direct' as const,
|
||||
};
|
||||
const mockUser = { userName: 'Tester', pronouns: 'they/them', timezone: 'UTC' };
|
||||
const mockTools = { credentialsLocation: '/dev/null' };
|
||||
|
||||
const mockSvc = {
|
||||
readSoul: vi.fn().mockResolvedValue(mockSoul),
|
||||
readUser: vi.fn().mockResolvedValue(mockUser),
|
||||
readTools: vi.fn().mockResolvedValue(mockTools),
|
||||
writeSoul: vi.fn().mockResolvedValue(undefined),
|
||||
writeUser: vi.fn().mockResolvedValue(undefined),
|
||||
writeTools: vi.fn().mockResolvedValue(undefined),
|
||||
syncFramework: vi.fn().mockResolvedValue(undefined),
|
||||
readAll: vi.fn().mockResolvedValue({ soul: mockSoul, user: mockUser, tools: mockTools }),
|
||||
getValue: vi.fn().mockResolvedValue('TestBot'),
|
||||
setValue: vi.fn().mockResolvedValue('OldBot'),
|
||||
getConfigPath: vi
|
||||
.fn()
|
||||
.mockImplementation((section?: string) =>
|
||||
section
|
||||
? `/home/user/.config/mosaic/${section.toUpperCase()}.md`
|
||||
: '/home/user/.config/mosaic',
|
||||
),
|
||||
isInitialized: vi.fn().mockReturnValue(true),
|
||||
};
|
||||
|
||||
// Mock the config-service module so commands use our mock.
|
||||
vi.mock('../config/config-service.js', () => ({
|
||||
createConfigService: vi.fn(() => mockSvc),
|
||||
}));
|
||||
|
||||
// Also mock child_process for the edit command.
|
||||
vi.mock('node:child_process', () => ({
|
||||
spawnSync: vi.fn().mockReturnValue({ status: 0, error: undefined }),
|
||||
}));
|
||||
|
||||
// ── config show ───────────────────────────────────────────────────────────────
|
||||
|
||||
describe('config show', () => {
|
||||
let consoleSpy: ReturnType<typeof vi.spyOn>;
|
||||
|
||||
beforeEach(() => {
|
||||
consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
|
||||
vi.clearAllMocks();
|
||||
mockSvc.isInitialized.mockReturnValue(true);
|
||||
mockSvc.readAll.mockResolvedValue({ soul: mockSoul, user: mockUser, tools: mockTools });
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
consoleSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('calls readAll() and prints a table by default', async () => {
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'show']);
|
||||
expect(mockSvc.readAll).toHaveBeenCalledOnce();
|
||||
// Should have printed something
|
||||
expect(consoleSpy).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('prints JSON when --format json is passed', async () => {
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'show', '--format', 'json']);
|
||||
expect(mockSvc.readAll).toHaveBeenCalledOnce();
|
||||
// Verify JSON was logged
|
||||
const allOutput = consoleSpy.mock.calls.map((c) => c[0] as string).join('\n');
|
||||
expect(allOutput).toContain('"agentName"');
|
||||
});
|
||||
});
|
||||
|
||||
// ── config get ────────────────────────────────────────────────────────────────
|
||||
|
||||
describe('config get', () => {
|
||||
let consoleSpy: ReturnType<typeof vi.spyOn>;
|
||||
|
||||
beforeEach(() => {
|
||||
consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
|
||||
vi.clearAllMocks();
|
||||
mockSvc.isInitialized.mockReturnValue(true);
|
||||
mockSvc.getValue.mockResolvedValue('TestBot');
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
consoleSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('delegates to getValue() with the provided key', async () => {
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'get', 'soul.agentName']);
|
||||
expect(mockSvc.getValue).toHaveBeenCalledWith('soul.agentName');
|
||||
});
|
||||
|
||||
it('prints the returned value', async () => {
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'get', 'soul.agentName']);
|
||||
expect(consoleSpy).toHaveBeenCalledWith('TestBot');
|
||||
});
|
||||
});
|
||||
|
||||
// ── config set ────────────────────────────────────────────────────────────────
|
||||
|
||||
describe('config set', () => {
|
||||
let consoleSpy: ReturnType<typeof vi.spyOn>;
|
||||
|
||||
beforeEach(() => {
|
||||
consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
|
||||
vi.clearAllMocks();
|
||||
mockSvc.isInitialized.mockReturnValue(true);
|
||||
mockSvc.setValue.mockResolvedValue('OldBot');
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
consoleSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('delegates to setValue() with key and value', async () => {
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'set', 'soul.agentName', 'NewBot']);
|
||||
expect(mockSvc.setValue).toHaveBeenCalledWith('soul.agentName', 'NewBot');
|
||||
});
|
||||
|
||||
it('prints old and new values', async () => {
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'set', 'soul.agentName', 'NewBot']);
|
||||
const output = consoleSpy.mock.calls.map((c) => c[0] as string).join('\n');
|
||||
expect(output).toContain('OldBot');
|
||||
expect(output).toContain('NewBot');
|
||||
});
|
||||
});
|
||||
|
||||
// ── config path ───────────────────────────────────────────────────────────────
|
||||
|
||||
describe('config path', () => {
|
||||
let consoleSpy: ReturnType<typeof vi.spyOn>;
|
||||
|
||||
beforeEach(() => {
|
||||
consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
|
||||
vi.clearAllMocks();
|
||||
mockSvc.getConfigPath.mockImplementation((section?: string) =>
|
||||
section
|
||||
? `/home/user/.config/mosaic/${section.toUpperCase()}.md`
|
||||
: '/home/user/.config/mosaic',
|
||||
);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
consoleSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('prints the mosaicHome directory when no section is specified', async () => {
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'path']);
|
||||
expect(mockSvc.getConfigPath).toHaveBeenCalledWith();
|
||||
expect(consoleSpy).toHaveBeenCalledWith('/home/user/.config/mosaic');
|
||||
});
|
||||
|
||||
it('prints the section file path when --section is given', async () => {
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'path', '--section', 'soul']);
|
||||
expect(mockSvc.getConfigPath).toHaveBeenCalledWith('soul');
|
||||
expect(consoleSpy).toHaveBeenCalledWith('/home/user/.config/mosaic/SOUL.md');
|
||||
});
|
||||
});
|
||||
|
||||
// ── config edit ───────────────────────────────────────────────────────────────
|
||||
|
||||
describe('config edit', () => {
|
||||
let consoleSpy: ReturnType<typeof vi.spyOn>;
|
||||
let spawnSyncMock: ReturnType<typeof vi.fn>;
|
||||
|
||||
beforeEach(async () => {
|
||||
consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
|
||||
vi.clearAllMocks();
|
||||
mockSvc.isInitialized.mockReturnValue(true);
|
||||
mockSvc.readAll.mockResolvedValue({ soul: mockSoul, user: mockUser, tools: mockTools });
|
||||
mockSvc.getConfigPath.mockImplementation((section?: string) =>
|
||||
section
|
||||
? `/home/user/.config/mosaic/${section.toUpperCase()}.md`
|
||||
: '/home/user/.config/mosaic',
|
||||
);
|
||||
|
||||
// Re-import to get the mock reference
|
||||
const cp = await import('node:child_process');
|
||||
spawnSyncMock = cp.spawnSync as ReturnType<typeof vi.fn>;
|
||||
spawnSyncMock.mockReturnValue({ status: 0, error: undefined });
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
consoleSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('calls spawnSync with the editor binary and config path', async () => {
|
||||
process.env['EDITOR'] = 'nano';
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'edit']);
|
||||
expect(spawnSyncMock).toHaveBeenCalledWith(
|
||||
'nano',
|
||||
['/home/user/.config/mosaic'],
|
||||
expect.objectContaining({ stdio: 'inherit' }),
|
||||
);
|
||||
delete process.env['EDITOR'];
|
||||
});
|
||||
|
||||
it('falls back to "vi" when EDITOR is not set', async () => {
|
||||
delete process.env['EDITOR'];
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'edit']);
|
||||
expect(spawnSyncMock).toHaveBeenCalledWith('vi', expect.any(Array), expect.any(Object));
|
||||
});
|
||||
|
||||
it('opens the section-specific file when --section is provided', async () => {
|
||||
process.env['EDITOR'] = 'code';
|
||||
const program = buildProgram();
|
||||
await program.parseAsync(['node', 'mosaic', 'config', 'edit', '--section', 'soul']);
|
||||
expect(spawnSyncMock).toHaveBeenCalledWith(
|
||||
'code',
|
||||
['/home/user/.config/mosaic/SOUL.md'],
|
||||
expect.any(Object),
|
||||
);
|
||||
delete process.env['EDITOR'];
|
||||
});
|
||||
});
|
||||
|
||||
// ── not-initialized guard ────────────────────────────────────────────────────
|
||||
|
||||
describe('not-initialized guard', () => {
|
||||
let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
|
||||
|
||||
beforeEach(() => {
|
||||
consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
|
||||
vi.clearAllMocks();
|
||||
mockSvc.isInitialized.mockReturnValue(false);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
consoleErrorSpy.mockRestore();
|
||||
mockSvc.isInitialized.mockReturnValue(true);
|
||||
});
|
||||
|
||||
it('prints a helpful message when config is missing (show)', async () => {
|
||||
const program = buildProgram();
|
||||
// process.exit is intercepted; catch the resulting error from exitOverride
|
||||
await expect(program.parseAsync(['node', 'mosaic', 'config', 'show'])).rejects.toThrow();
|
||||
expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('mosaic wizard'));
|
||||
});
|
||||
});
|
||||
@@ -1,206 +0,0 @@
|
||||
import { spawnSync } from 'node:child_process';
|
||||
import type { Command } from 'commander';
|
||||
import { createConfigService } from '../config/config-service.js';
|
||||
import { DEFAULT_MOSAIC_HOME } from '../constants.js';
|
||||
|
||||
/**
|
||||
* Resolve mosaicHome from the MOSAIC_HOME env var or the default constant.
|
||||
*/
|
||||
function getMosaicHome(): string {
|
||||
return process.env['MOSAIC_HOME'] ?? DEFAULT_MOSAIC_HOME;
|
||||
}
|
||||
|
||||
/**
|
||||
* Guard: print an error and exit(1) if config has not been initialised.
|
||||
*/
|
||||
function assertInitialized(svc: ReturnType<typeof createConfigService>): void {
|
||||
if (!svc.isInitialized()) {
|
||||
console.error('No config found — run `mosaic wizard` first.');
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Flatten a nested object into dotted-key rows for table display.
|
||||
*/
|
||||
function flattenConfig(obj: Record<string, unknown>, prefix = ''): Array<[string, string]> {
|
||||
const rows: Array<[string, string]> = [];
|
||||
for (const [k, v] of Object.entries(obj)) {
|
||||
const key = prefix ? `${prefix}.${k}` : k;
|
||||
if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
|
||||
rows.push(...flattenConfig(v as Record<string, unknown>, key));
|
||||
} else {
|
||||
rows.push([key, v === undefined || v === null ? '' : String(v)]);
|
||||
}
|
||||
}
|
||||
return rows;
|
||||
}
|
||||
|
||||
/**
|
||||
* Print rows as a padded ASCII table.
|
||||
*/
|
||||
function printTable(rows: Array<[string, string]>): void {
|
||||
if (rows.length === 0) {
|
||||
console.log('(no config values)');
|
||||
return;
|
||||
}
|
||||
const maxKey = Math.max(...rows.map(([k]) => k.length));
|
||||
const header = `${'Key'.padEnd(maxKey)} Value`;
|
||||
const divider = '-'.repeat(header.length);
|
||||
console.log(header);
|
||||
console.log(divider);
|
||||
for (const [k, v] of rows) {
|
||||
console.log(`${k.padEnd(maxKey)} ${v}`);
|
||||
}
|
||||
}
|
||||
|
||||
export function registerConfigCommand(program: Command): void {
|
||||
const cmd = program
|
||||
.command('config')
|
||||
.description('Manage Mosaic framework configuration')
|
||||
.configureHelp({ sortSubcommands: true });
|
||||
|
||||
// ── config show ─────────────────────────────────────────────────────────
|
||||
|
||||
cmd
|
||||
.command('show')
|
||||
.description('Print the current resolved config')
|
||||
.option('-f, --format <format>', 'Output format: table or json', 'table')
|
||||
.action(async (opts: { format: string }) => {
|
||||
const mosaicHome = getMosaicHome();
|
||||
const svc = createConfigService(mosaicHome, mosaicHome);
|
||||
assertInitialized(svc);
|
||||
|
||||
const config = await svc.readAll();
|
||||
|
||||
if (opts.format === 'json') {
|
||||
console.log(JSON.stringify(config, null, 2));
|
||||
return;
|
||||
}
|
||||
|
||||
// Default: table
|
||||
const rows = flattenConfig(config as unknown as Record<string, unknown>);
|
||||
printTable(rows);
|
||||
});
|
||||
|
||||
// ── config get <key> ────────────────────────────────────────────────────
|
||||
|
||||
cmd
|
||||
.command('get <key>')
|
||||
.description('Print a single config value (supports dotted keys, e.g. soul.agentName)')
|
||||
.action(async (key: string) => {
|
||||
const mosaicHome = getMosaicHome();
|
||||
const svc = createConfigService(mosaicHome, mosaicHome);
|
||||
assertInitialized(svc);
|
||||
|
||||
const value = await svc.getValue(key);
|
||||
if (value === undefined) {
|
||||
console.error(`Key "${key}" not found.`);
|
||||
process.exit(1);
|
||||
}
|
||||
if (typeof value === 'object') {
|
||||
console.log(JSON.stringify(value, null, 2));
|
||||
} else {
|
||||
console.log(String(value));
|
||||
}
|
||||
});
|
||||
|
||||
// ── config set <key> <value> ────────────────────────────────────────────
|
||||
|
||||
cmd
|
||||
.command('set <key> <value>')
|
||||
.description(
|
||||
'Set a config value and persist (supports dotted keys, e.g. soul.agentName "Jarvis")',
|
||||
)
|
||||
.action(async (key: string, value: string) => {
|
||||
const mosaicHome = getMosaicHome();
|
||||
const svc = createConfigService(mosaicHome, mosaicHome);
|
||||
assertInitialized(svc);
|
||||
|
||||
let previous: unknown;
|
||||
try {
|
||||
previous = await svc.setValue(key, value);
|
||||
} catch (err) {
|
||||
console.error(err instanceof Error ? err.message : String(err));
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const prevStr = previous === undefined ? '(unset)' : String(previous);
|
||||
console.log(`${key}`);
|
||||
console.log(` old: ${prevStr}`);
|
||||
console.log(` new: ${value}`);
|
||||
});
|
||||
|
||||
// ── config edit ─────────────────────────────────────────────────────────
|
||||
|
||||
cmd
|
||||
.command('edit')
|
||||
.description('Open the config directory in $EDITOR (or vi)')
|
||||
.option('-s, --section <section>', 'Open a specific section file: soul | user | tools')
|
||||
.action(async (opts: { section?: string }) => {
|
||||
const mosaicHome = getMosaicHome();
|
||||
const svc = createConfigService(mosaicHome, mosaicHome);
|
||||
assertInitialized(svc);
|
||||
|
||||
const editor = process.env['EDITOR'] ?? 'vi';
|
||||
|
||||
let targetPath: string;
|
||||
if (opts.section) {
|
||||
const validSections = ['soul', 'user', 'tools'] as const;
|
||||
if (!validSections.includes(opts.section as (typeof validSections)[number])) {
|
||||
console.error(`Invalid section "${opts.section}". Choose: soul, user, tools`);
|
||||
process.exit(1);
|
||||
}
|
||||
targetPath = svc.getConfigPath(opts.section as 'soul' | 'user' | 'tools');
|
||||
} else {
|
||||
targetPath = svc.getConfigPath();
|
||||
}
|
||||
|
||||
const result = spawnSync(editor, [targetPath], { stdio: 'inherit' });
|
||||
|
||||
if (result.error) {
|
||||
console.error(`Failed to open editor: ${result.error.message}`);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
if (result.status !== 0) {
|
||||
console.error(`Editor exited with code ${String(result.status ?? 1)}`);
|
||||
process.exit(result.status ?? 1);
|
||||
}
|
||||
|
||||
// Re-read after edit and report any issues
|
||||
try {
|
||||
await svc.readAll();
|
||||
console.log('Config looks valid.');
|
||||
} catch (err) {
|
||||
console.error('Warning: config may have validation issues:');
|
||||
console.error(err instanceof Error ? err.message : String(err));
|
||||
process.exit(1);
|
||||
}
|
||||
});
|
||||
|
||||
// ── config path ─────────────────────────────────────────────────────────
|
||||
|
||||
cmd
|
||||
.command('path')
|
||||
.description('Print the active config directory path (for scripting)')
|
||||
.option(
|
||||
'-s, --section <section>',
|
||||
'Print path for a specific section file: soul | user | tools',
|
||||
)
|
||||
.action(async (opts: { section?: string }) => {
|
||||
const mosaicHome = getMosaicHome();
|
||||
const svc = createConfigService(mosaicHome, mosaicHome);
|
||||
|
||||
if (opts.section) {
|
||||
const validSections = ['soul', 'user', 'tools'] as const;
|
||||
if (!validSections.includes(opts.section as (typeof validSections)[number])) {
|
||||
console.error(`Invalid section "${opts.section}". Choose: soul, user, tools`);
|
||||
process.exit(1);
|
||||
}
|
||||
console.log(svc.getConfigPath(opts.section as 'soul' | 'user' | 'tools'));
|
||||
} else {
|
||||
console.log(svc.getConfigPath());
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -30,7 +30,6 @@ export function registerGatewayCommand(program: Command): void {
|
||||
.option('-h, --host <host>', 'Gateway host', 'localhost')
|
||||
.option('-p, --port <port>', 'Gateway port', '14242')
|
||||
.option('-t, --token <token>', 'Admin API token')
|
||||
.configureHelp({ sortSubcommands: true })
|
||||
.action(() => {
|
||||
gw.outputHelp();
|
||||
});
|
||||
|
||||
@@ -47,7 +47,6 @@ export function registerMissionCommand(program: Command) {
|
||||
.option('--update <idOrName>', 'Update a mission')
|
||||
.option('--project <idOrName>', 'Scope to project')
|
||||
.argument('[id]', 'Show mission detail by ID')
|
||||
.configureHelp({ sortSubcommands: true })
|
||||
.action(
|
||||
async (
|
||||
id: string | undefined,
|
||||
|
||||
@@ -1,16 +1,6 @@
|
||||
import type { SoulConfig, UserConfig, ToolsConfig, InstallAction } from '../types.js';
|
||||
import { FileConfigAdapter } from './file-adapter.js';
|
||||
|
||||
/** Supported top-level config sections for dotted-key access. */
|
||||
export type ConfigSection = 'soul' | 'user' | 'tools';
|
||||
|
||||
/** A resolved view of all config sections, keyed by section name. */
|
||||
export interface ResolvedConfig {
|
||||
soul: SoulConfig;
|
||||
user: UserConfig;
|
||||
tools: ToolsConfig;
|
||||
}
|
||||
|
||||
/**
|
||||
* ConfigService interface — abstracts config read/write operations.
|
||||
* Currently backed by FileConfigAdapter (writes .md files from templates).
|
||||
@@ -26,35 +16,6 @@ export interface ConfigService {
|
||||
writeTools(config: ToolsConfig): Promise<void>;
|
||||
|
||||
syncFramework(action: InstallAction): Promise<void>;
|
||||
|
||||
/**
|
||||
* Return the resolved (merged) config across all sections.
|
||||
*/
|
||||
readAll(): Promise<ResolvedConfig>;
|
||||
|
||||
/**
|
||||
* Read a single value by dotted key (e.g. "soul.agentName").
|
||||
* Returns undefined if the key doesn't exist.
|
||||
*/
|
||||
getValue(dottedKey: string): Promise<unknown>;
|
||||
|
||||
/**
|
||||
* Set a single value by dotted key (e.g. "soul.agentName") and persist.
|
||||
* Returns the previous value (or undefined).
|
||||
*/
|
||||
setValue(dottedKey: string, value: string): Promise<unknown>;
|
||||
|
||||
/**
|
||||
* Return the filesystem path for a given config section file.
|
||||
* When no section is provided, returns the mosaicHome directory.
|
||||
*/
|
||||
getConfigPath(section?: ConfigSection): string;
|
||||
|
||||
/**
|
||||
* Returns true if the mosaicHome directory exists and at least one
|
||||
* config file (SOUL.md, USER.md, TOOLS.md) is present.
|
||||
*/
|
||||
isInitialized(): boolean;
|
||||
}
|
||||
|
||||
export function createConfigService(mosaicHome: string, sourceDir: string): ConfigService {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { readFileSync, existsSync, readdirSync, statSync, copyFileSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import type { ConfigService, ConfigSection, ResolvedConfig } from './config-service.js';
|
||||
import type { ConfigService } from './config-service.js';
|
||||
import type { SoulConfig, UserConfig, ToolsConfig, InstallAction } from '../types.js';
|
||||
import { soulSchema, userSchema, toolsSchema } from './schemas.js';
|
||||
import { renderTemplate } from '../template/engine.js';
|
||||
@@ -159,73 +159,6 @@ export class FileConfigAdapter implements ConfigService {
|
||||
}
|
||||
}
|
||||
|
||||
async readAll(): Promise<ResolvedConfig> {
|
||||
const [soul, user, tools] = await Promise.all([
|
||||
this.readSoul(),
|
||||
this.readUser(),
|
||||
this.readTools(),
|
||||
]);
|
||||
return { soul, user, tools };
|
||||
}
|
||||
|
||||
async getValue(dottedKey: string): Promise<unknown> {
|
||||
const parts = dottedKey.split('.');
|
||||
const section = parts[0] ?? '';
|
||||
const field = parts.slice(1).join('.');
|
||||
const config = await this.readAll();
|
||||
if (!this.isValidSection(section)) return undefined;
|
||||
const sectionData = config[section as ConfigSection] as Record<string, unknown>;
|
||||
return field ? sectionData[field] : sectionData;
|
||||
}
|
||||
|
||||
async setValue(dottedKey: string, value: string): Promise<unknown> {
|
||||
const parts = dottedKey.split('.');
|
||||
const section = parts[0] ?? '';
|
||||
const field = parts.slice(1).join('.');
|
||||
if (!this.isValidSection(section) || !field) {
|
||||
throw new Error(
|
||||
`Invalid key "${dottedKey}". Use format <section>.<field> (e.g. soul.agentName).`,
|
||||
);
|
||||
}
|
||||
|
||||
const previous = await this.getValue(dottedKey);
|
||||
|
||||
if (section === 'soul') {
|
||||
const current = await this.readSoul();
|
||||
await this.writeSoul({ ...current, [field]: value });
|
||||
} else if (section === 'user') {
|
||||
const current = await this.readUser();
|
||||
await this.writeUser({ ...current, [field]: value });
|
||||
} else {
|
||||
const current = await this.readTools();
|
||||
await this.writeTools({ ...current, [field]: value });
|
||||
}
|
||||
|
||||
return previous;
|
||||
}
|
||||
|
||||
getConfigPath(section?: ConfigSection): string {
|
||||
if (!section) return this.mosaicHome;
|
||||
const fileMap: Record<ConfigSection, string> = {
|
||||
soul: join(this.mosaicHome, 'SOUL.md'),
|
||||
user: join(this.mosaicHome, 'USER.md'),
|
||||
tools: join(this.mosaicHome, 'TOOLS.md'),
|
||||
};
|
||||
return fileMap[section];
|
||||
}
|
||||
|
||||
isInitialized(): boolean {
|
||||
return (
|
||||
existsSync(join(this.mosaicHome, 'SOUL.md')) ||
|
||||
existsSync(join(this.mosaicHome, 'USER.md')) ||
|
||||
existsSync(join(this.mosaicHome, 'TOOLS.md'))
|
||||
);
|
||||
}
|
||||
|
||||
private isValidSection(s: string): s is ConfigSection {
|
||||
return s === 'soul' || s === 'user' || s === 'tools';
|
||||
}
|
||||
|
||||
/**
|
||||
* Look for template in source dir first, then mosaic home.
|
||||
*/
|
||||
|
||||
@@ -22,7 +22,6 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@mosaicstack/types": "workspace:*",
|
||||
"commander": "^13.0.0",
|
||||
"ioredis": "^5.10.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
|
||||
@@ -1,62 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { Command } from 'commander';
|
||||
import { registerQueueCommand } from './cli.js';
|
||||
|
||||
describe('registerQueueCommand', () => {
|
||||
function buildProgram(): Command {
|
||||
const program = new Command('mosaic');
|
||||
registerQueueCommand(program);
|
||||
return program;
|
||||
}
|
||||
|
||||
it('registers a "queue" subcommand', () => {
|
||||
const program = buildProgram();
|
||||
const queueCmd = program.commands.find((c) => c.name() === 'queue');
|
||||
expect(queueCmd).toBeDefined();
|
||||
});
|
||||
|
||||
it('queue has list, stats, pause, resume, jobs, drain subcommands', () => {
|
||||
const program = buildProgram();
|
||||
const queueCmd = program.commands.find((c) => c.name() === 'queue');
|
||||
expect(queueCmd).toBeDefined();
|
||||
|
||||
const names = queueCmd!.commands.map((c) => c.name());
|
||||
expect(names).toContain('list');
|
||||
expect(names).toContain('stats');
|
||||
expect(names).toContain('pause');
|
||||
expect(names).toContain('resume');
|
||||
expect(names).toContain('jobs');
|
||||
expect(names).toContain('drain');
|
||||
});
|
||||
|
||||
it('jobs subcommand has a "tail" subcommand', () => {
|
||||
const program = buildProgram();
|
||||
const queueCmd = program.commands.find((c) => c.name() === 'queue');
|
||||
const jobsCmd = queueCmd!.commands.find((c) => c.name() === 'jobs');
|
||||
expect(jobsCmd).toBeDefined();
|
||||
|
||||
const tailCmd = jobsCmd!.commands.find((c) => c.name() === 'tail');
|
||||
expect(tailCmd).toBeDefined();
|
||||
});
|
||||
|
||||
it('drain has a --yes option', () => {
|
||||
const program = buildProgram();
|
||||
const queueCmd = program.commands.find((c) => c.name() === 'queue');
|
||||
const drainCmd = queueCmd!.commands.find((c) => c.name() === 'drain');
|
||||
expect(drainCmd).toBeDefined();
|
||||
|
||||
const optionNames = drainCmd!.options.map((o) => o.long);
|
||||
expect(optionNames).toContain('--yes');
|
||||
});
|
||||
|
||||
it('stats accepts an optional [name] argument', () => {
|
||||
const program = buildProgram();
|
||||
const queueCmd = program.commands.find((c) => c.name() === 'queue');
|
||||
const statsCmd = queueCmd!.commands.find((c) => c.name() === 'stats');
|
||||
expect(statsCmd).toBeDefined();
|
||||
// Should not throw when called without argument
|
||||
const args = statsCmd!.registeredArguments;
|
||||
expect(args.length).toBe(1);
|
||||
expect(args[0]!.required).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -1,248 +0,0 @@
|
||||
import type { Command } from 'commander';
|
||||
|
||||
import { createLocalAdapter } from './adapters/local.js';
|
||||
import type { QueueConfig } from './types.js';
|
||||
|
||||
/** Resolve adapter type from env; defaults to 'local'. */
|
||||
function resolveAdapterType(): 'bullmq' | 'local' {
|
||||
const t = process.env['QUEUE_ADAPTER'] ?? 'local';
|
||||
return t === 'bullmq' ? 'bullmq' : 'local';
|
||||
}
|
||||
|
||||
function resolveConfig(): QueueConfig {
|
||||
const type = resolveAdapterType();
|
||||
if (type === 'bullmq') {
|
||||
return { type: 'bullmq', url: process.env['VALKEY_URL'] };
|
||||
}
|
||||
return { type: 'local', dataDir: process.env['QUEUE_DATA_DIR'] };
|
||||
}
|
||||
|
||||
const BULLMQ_ONLY_MSG =
|
||||
'not supported by local adapter — use the bullmq tier for this (set QUEUE_ADAPTER=bullmq)';
|
||||
|
||||
/**
|
||||
* Register queue subcommands on an existing Commander program.
|
||||
* Follows the same pattern as registerQualityRails in @mosaicstack/quality-rails.
|
||||
*/
|
||||
export function registerQueueCommand(parent: Command): void {
|
||||
buildQueueCommand(parent.command('queue').description('Manage Mosaic job queues'));
|
||||
}
|
||||
|
||||
function buildQueueCommand(queue: Command): void {
|
||||
// ─── list ──────────────────────────────────────────────────────────────
|
||||
queue
|
||||
.command('list')
|
||||
.description('List all queues known to the configured adapter')
|
||||
.action(async () => {
|
||||
const config = resolveConfig();
|
||||
|
||||
if (config.type === 'local') {
|
||||
const adapter = createLocalAdapter(config);
|
||||
// Local adapter tracks queues in its internal Map; we expose them by
|
||||
// listing JSON files in the data dir.
|
||||
const { readdirSync } = await import('node:fs');
|
||||
const { existsSync } = await import('node:fs');
|
||||
const dataDir = config.dataDir ?? '.mosaic/queue';
|
||||
if (!existsSync(dataDir)) {
|
||||
console.log('No queues found (data dir does not exist yet).');
|
||||
await adapter.close();
|
||||
return;
|
||||
}
|
||||
const files = readdirSync(dataDir).filter((f: string) => f.endsWith('.json'));
|
||||
if (files.length === 0) {
|
||||
console.log('No queues found.');
|
||||
} else {
|
||||
console.log('Queues (local adapter):');
|
||||
for (const f of files) {
|
||||
console.log(` - ${f.slice(0, -5)}`);
|
||||
}
|
||||
}
|
||||
await adapter.close();
|
||||
return;
|
||||
}
|
||||
|
||||
// bullmq — not enough info to enumerate queues without a BullMQ Board
|
||||
console.log(BULLMQ_ONLY_MSG);
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
// ─── stats ─────────────────────────────────────────────────────────────
|
||||
queue
|
||||
.command('stats [name]')
|
||||
.description('Show stats for a queue (or all queues)')
|
||||
.action(async (name?: string) => {
|
||||
const config = resolveConfig();
|
||||
|
||||
if (config.type === 'local') {
|
||||
const adapter = createLocalAdapter(config);
|
||||
const { readdirSync } = await import('node:fs');
|
||||
const { existsSync } = await import('node:fs');
|
||||
const dataDir = config.dataDir ?? '.mosaic/queue';
|
||||
|
||||
let names: string[] = [];
|
||||
if (name) {
|
||||
names = [name];
|
||||
} else {
|
||||
if (existsSync(dataDir)) {
|
||||
names = readdirSync(dataDir)
|
||||
.filter((f: string) => f.endsWith('.json'))
|
||||
.map((f: string) => f.slice(0, -5));
|
||||
}
|
||||
}
|
||||
|
||||
if (names.length === 0) {
|
||||
console.log('No queues found.');
|
||||
await adapter.close();
|
||||
return;
|
||||
}
|
||||
|
||||
for (const queueName of names) {
|
||||
const len = await adapter.length(queueName);
|
||||
console.log(`Queue: ${queueName}`);
|
||||
console.log(` waiting: ${len}`);
|
||||
console.log(` active: 0 (local adapter — no active tracking)`);
|
||||
console.log(` completed: 0 (local adapter — no completed tracking)`);
|
||||
console.log(` failed: 0 (local adapter — no failed tracking)`);
|
||||
console.log(` delayed: 0 (local adapter — no delayed tracking)`);
|
||||
}
|
||||
await adapter.close();
|
||||
return;
|
||||
}
|
||||
|
||||
// bullmq
|
||||
console.log(BULLMQ_ONLY_MSG);
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
// ─── pause ─────────────────────────────────────────────────────────────
|
||||
queue
|
||||
.command('pause <name>')
|
||||
.description('Pause job processing for a queue')
|
||||
.action(async (_name: string) => {
|
||||
const config = resolveConfig();
|
||||
|
||||
if (config.type === 'local') {
|
||||
console.log(BULLMQ_ONLY_MSG);
|
||||
process.exit(0);
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(BULLMQ_ONLY_MSG);
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
// ─── resume ────────────────────────────────────────────────────────────
|
||||
queue
|
||||
.command('resume <name>')
|
||||
.description('Resume job processing for a queue')
|
||||
.action(async (_name: string) => {
|
||||
const config = resolveConfig();
|
||||
|
||||
if (config.type === 'local') {
|
||||
console.log(BULLMQ_ONLY_MSG);
|
||||
process.exit(0);
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(BULLMQ_ONLY_MSG);
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
// ─── jobs tail ─────────────────────────────────────────────────────────
|
||||
const jobs = queue.command('jobs').description('Job-level operations');
|
||||
|
||||
jobs
|
||||
.command('tail [name]')
|
||||
.description('Stream new jobs as they arrive (poll-based)')
|
||||
.option('--interval <ms>', 'Poll interval in ms', '2000')
|
||||
.action(async (name: string | undefined, opts: { interval: string }) => {
|
||||
const config = resolveConfig();
|
||||
const pollMs = parseInt(opts.interval, 10);
|
||||
|
||||
if (config.type === 'local') {
|
||||
const adapter = createLocalAdapter(config);
|
||||
const { existsSync, readdirSync } = await import('node:fs');
|
||||
const dataDir = config.dataDir ?? '.mosaic/queue';
|
||||
|
||||
let names: string[] = [];
|
||||
if (name) {
|
||||
names = [name];
|
||||
} else {
|
||||
if (existsSync(dataDir)) {
|
||||
names = readdirSync(dataDir)
|
||||
.filter((f: string) => f.endsWith('.json'))
|
||||
.map((f: string) => f.slice(0, -5));
|
||||
}
|
||||
}
|
||||
|
||||
if (names.length === 0) {
|
||||
console.log('No queues to tail.');
|
||||
await adapter.close();
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`Tailing queues: ${names.join(', ')} (Ctrl-C to stop)`);
|
||||
const lastLen = new Map<string, number>();
|
||||
for (const qn of names) {
|
||||
lastLen.set(qn, await adapter.length(qn));
|
||||
}
|
||||
|
||||
const timer = setInterval(async () => {
|
||||
for (const qn of names) {
|
||||
const len = await adapter.length(qn);
|
||||
const prev = lastLen.get(qn) ?? 0;
|
||||
if (len > prev) {
|
||||
console.log(
|
||||
`[${new Date().toISOString()}] ${qn}: ${len - prev} new job(s) (total: ${len})`,
|
||||
);
|
||||
}
|
||||
lastLen.set(qn, len);
|
||||
}
|
||||
}, pollMs);
|
||||
|
||||
process.on('SIGINT', async () => {
|
||||
clearInterval(timer);
|
||||
await adapter.close();
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// bullmq — use subscribe on the channel
|
||||
console.log(BULLMQ_ONLY_MSG);
|
||||
process.exit(0);
|
||||
});
|
||||
|
||||
// ─── drain ─────────────────────────────────────────────────────────────
|
||||
queue
|
||||
.command('drain <name>')
|
||||
.description('Drain all pending jobs from a queue')
|
||||
.option('--yes', 'Skip confirmation prompt')
|
||||
.action(async (name: string, opts: { yes?: boolean }) => {
|
||||
if (!opts.yes) {
|
||||
console.error(
|
||||
`WARNING: This will remove all pending jobs from queue "${name}". Re-run with --yes to confirm.`,
|
||||
);
|
||||
process.exit(1);
|
||||
return;
|
||||
}
|
||||
|
||||
const config = resolveConfig();
|
||||
|
||||
if (config.type === 'local') {
|
||||
const adapter = createLocalAdapter(config);
|
||||
let removed = 0;
|
||||
while ((await adapter.length(name)) > 0) {
|
||||
await adapter.dequeue(name);
|
||||
removed++;
|
||||
}
|
||||
console.log(`Drained ${removed} job(s) from queue "${name}".`);
|
||||
await adapter.close();
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(BULLMQ_ONLY_MSG);
|
||||
process.exit(0);
|
||||
});
|
||||
}
|
||||
@@ -11,7 +11,6 @@ export { type QueueAdapter, type QueueConfig as QueueAdapterConfig } from './typ
|
||||
export { createQueueAdapter, registerQueueAdapter } from './factory.js';
|
||||
export { createBullMQAdapter } from './adapters/bullmq.js';
|
||||
export { createLocalAdapter } from './adapters/local.js';
|
||||
export { registerQueueCommand } from './cli.js';
|
||||
|
||||
import { registerQueueAdapter } from './factory.js';
|
||||
import { createBullMQAdapter } from './adapters/bullmq.js';
|
||||
|
||||
60
pnpm-lock.yaml
generated
60
pnpm-lock.yaml
generated
@@ -385,9 +385,6 @@ importers:
|
||||
'@mosaicstack/macp':
|
||||
specifier: workspace:*
|
||||
version: link:../macp
|
||||
commander:
|
||||
specifier: ^13.0.0
|
||||
version: 13.1.0
|
||||
devDependencies:
|
||||
'@types/node':
|
||||
specifier: ^22.0.0
|
||||
@@ -478,9 +475,6 @@ importers:
|
||||
'@mosaicstack/quality-rails':
|
||||
specifier: workspace:*
|
||||
version: link:../quality-rails
|
||||
'@mosaicstack/queue':
|
||||
specifier: workspace:*
|
||||
version: link:../queue
|
||||
'@mosaicstack/types':
|
||||
specifier: workspace:*
|
||||
version: link:../types
|
||||
@@ -577,9 +571,6 @@ importers:
|
||||
'@mosaicstack/types':
|
||||
specifier: workspace:*
|
||||
version: link:../types
|
||||
commander:
|
||||
specifier: ^13.0.0
|
||||
version: 13.1.0
|
||||
ioredis:
|
||||
specifier: ^5.10.0
|
||||
version: 5.10.0
|
||||
@@ -649,10 +640,10 @@ importers:
|
||||
dependencies:
|
||||
'@mariozechner/pi-agent-core':
|
||||
specifier: ^0.63.1
|
||||
version: 0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@3.25.76)
|
||||
version: 0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@4.3.6)
|
||||
'@mariozechner/pi-ai':
|
||||
specifier: ^0.63.1
|
||||
version: 0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@3.25.76)
|
||||
version: 0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@4.3.6)
|
||||
'@sinclair/typebox':
|
||||
specifier: ^0.34.41
|
||||
version: 0.34.48
|
||||
@@ -7027,12 +7018,6 @@ snapshots:
|
||||
'@jridgewell/gen-mapping': 0.3.13
|
||||
'@jridgewell/trace-mapping': 0.3.31
|
||||
|
||||
'@anthropic-ai/sdk@0.73.0(zod@3.25.76)':
|
||||
dependencies:
|
||||
json-schema-to-ts: 3.1.1
|
||||
optionalDependencies:
|
||||
zod: 3.25.76
|
||||
|
||||
'@anthropic-ai/sdk@0.73.0(zod@4.3.6)':
|
||||
dependencies:
|
||||
json-schema-to-ts: 3.1.1
|
||||
@@ -8374,18 +8359,6 @@ snapshots:
|
||||
- ws
|
||||
- zod
|
||||
|
||||
'@mariozechner/pi-agent-core@0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@3.25.76)':
|
||||
dependencies:
|
||||
'@mariozechner/pi-ai': 0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@3.25.76)
|
||||
transitivePeerDependencies:
|
||||
- '@modelcontextprotocol/sdk'
|
||||
- aws-crt
|
||||
- bufferutil
|
||||
- supports-color
|
||||
- utf-8-validate
|
||||
- ws
|
||||
- zod
|
||||
|
||||
'@mariozechner/pi-agent-core@0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@4.3.6)':
|
||||
dependencies:
|
||||
'@mariozechner/pi-ai': 0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@4.3.6)
|
||||
@@ -8434,30 +8407,6 @@ snapshots:
|
||||
- ws
|
||||
- zod
|
||||
|
||||
'@mariozechner/pi-ai@0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@3.25.76)':
|
||||
dependencies:
|
||||
'@anthropic-ai/sdk': 0.73.0(zod@3.25.76)
|
||||
'@aws-sdk/client-bedrock-runtime': 3.1008.0
|
||||
'@google/genai': 1.45.0(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))
|
||||
'@mistralai/mistralai': 1.14.1
|
||||
'@sinclair/typebox': 0.34.48
|
||||
ajv: 8.18.0
|
||||
ajv-formats: 3.0.1(ajv@8.18.0)
|
||||
chalk: 5.6.2
|
||||
openai: 6.26.0(ws@8.20.0)(zod@3.25.76)
|
||||
partial-json: 0.1.7
|
||||
proxy-agent: 6.5.0
|
||||
undici: 7.24.3
|
||||
zod-to-json-schema: 3.25.1(zod@3.25.76)
|
||||
transitivePeerDependencies:
|
||||
- '@modelcontextprotocol/sdk'
|
||||
- aws-crt
|
||||
- bufferutil
|
||||
- supports-color
|
||||
- utf-8-validate
|
||||
- ws
|
||||
- zod
|
||||
|
||||
'@mariozechner/pi-ai@0.63.2(@modelcontextprotocol/sdk@1.28.0(zod@4.3.6))(ws@8.20.0)(zod@4.3.6)':
|
||||
dependencies:
|
||||
'@anthropic-ai/sdk': 0.73.0(zod@4.3.6)
|
||||
@@ -12833,11 +12782,6 @@ snapshots:
|
||||
dependencies:
|
||||
mimic-function: 5.0.1
|
||||
|
||||
openai@6.26.0(ws@8.20.0)(zod@3.25.76):
|
||||
optionalDependencies:
|
||||
ws: 8.20.0
|
||||
zod: 3.25.76
|
||||
|
||||
openai@6.26.0(ws@8.20.0)(zod@4.3.6):
|
||||
optionalDependencies:
|
||||
ws: 8.20.0
|
||||
|
||||
Reference in New Issue
Block a user