feat(core): add a live-session registry and qwen sessions ps

packages/cli/src/commands/sessions.test.ts

@@ -6,13 +6,22 @@
 
 import { describe, it, expect, vi } from 'vitest';
 
+// Subcommand modules are stubbed so this file tests wiring only — loading
+// the real ones would pull the whole core barrel in behind them.
 vi.mock('./sessions/list.js', () => ({
   listCommand: {
     command: 'list',
     describe: 'List sessions',
   },
 }));
 
+vi.mock('./sessions/ps.js', () => ({
+  psCommand: {
+    command: 'ps',
+    describe: 'List Qwen Code sessions running right now',
+  },
+}));
+
 import { sessionsCommand } from './sessions.js';
 import { type Argv } from 'yargs';
 import yargs from 'yargs';
@@ -42,7 +51,7 @@ describe('sessions command', () => {
     expect(options.key).toHaveProperty('help');
   });
 
-  it('should register list subcommand', () => {
+  it('should register list and ps subcommands', () => {
     const mockYargs = {
       command: vi.fn().mockReturnThis(),
       demandCommand: vi.fn().mockReturnThis(),
@@ -55,12 +64,13 @@ describe('sessions command', () => {
     }
     builder(mockYargs as unknown as Argv);
 
-    expect(mockYargs.command).toHaveBeenCalledTimes(1);
+    expect(mockYargs.command).toHaveBeenCalledTimes(2);
 
     const commandCalls = mockYargs.command.mock.calls;
     const commandNames = commandCalls.map((call) => call[0].command);
 
     expect(commandNames).toContain('list');
+    expect(commandNames).toContain('ps');
 
     expect(mockYargs.demandCommand).toHaveBeenCalledWith(
       1,

packages/cli/src/commands/sessions.ts

@@ -6,13 +6,15 @@
 
 import type { CommandModule, Argv } from 'yargs';
 import { listCommand } from './sessions/list.js';
+import { psCommand } from './sessions/ps.js';
 
 export const sessionsCommand: CommandModule = {
   command: 'sessions',
   describe: 'Manage Qwen Code sessions',
   builder: (yargs: Argv) =>
     yargs
       .command(listCommand)
+      .command(psCommand)
       .demandCommand(1, 'You need at least one command before continuing.')
       .version(false),
   // demandCommand(1) ensures a subcommand is always required;

packages/cli/src/commands/sessions/ps.test.ts

@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import type { SessionRegistryRecord } from '@qwen-code/qwen-code-core';
+
+const listLiveSessions = vi.fn();
+
+vi.mock('@qwen-code/qwen-code-core', () => ({
+  listLiveSessions: (...args: unknown[]) => listLiveSessions(...args),
+}));
+
+const stdout: string[] = [];
+const stderr: string[] = [];
+
+vi.mock('../../utils/stdioHelpers.js', () => ({
+  writeStdoutLine: (line: string) => stdout.push(line),
+  writeStderrLine: (line: string) => stderr.push(line),
+}));
+
+const { psCommand, formatAge } = await import('./ps.js');
+
+function record(
+  over: Partial<SessionRegistryRecord> = {},
+): SessionRegistryRecord {
+  return {
+    schemaVersion: 1,
+    pid: 4242,
+    procStart: '123',
+    sessionId: 'sess-1',
+    cwd: '/w/app',
+    name: 'app-ab',
+    kind: 'interactive',
+    startedAt: Date.now() - 90_000,
+    qwenVersion: '1.0.0',
+    peerProtocol: 1,
+    ...over,
+  };
+}
+
+async function run(argv: Record<string, unknown>): Promise<void> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await (psCommand.handler as any)(argv);
+}
+
+beforeEach(() => {
+  stdout.length = 0;
+  stderr.length = 0;
+  listLiveSessions.mockReset();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('formatAge', () => {
+  it('scales the unit with the magnitude', () => {
+    expect(formatAge(5_000)).toBe('5s');
+    expect(formatAge(90_000)).toBe('1m');
+    expect(formatAge(3 * 3600_000)).toBe('3h');
+    expect(formatAge(50 * 3600_000)).toBe('2d');
+  });
+
+  it('clamps a record from the future to zero rather than showing a negative age', () => {
+    expect(formatAge(-10_000)).toBe('0s');
+  });
+});
+
+describe('qwen sessions ps', () => {
+  it('prints a table of live sessions', async () => {
+    listLiveSessions.mockResolvedValue([record()]);
+    await run({ json: false, all: false });
+
+    expect(stdout[0]).toMatch(/^NAME\s+PID\s+AGE\s+DIRECTORY$/);
+    expect(stdout[1]).toContain('app-ab');
+    expect(stdout[1]).toContain('4242');
+    expect(stdout[1]).toContain('/w/app');
+  });
+
+  it('says so plainly when nothing else is running', async () => {
+    listLiveSessions.mockResolvedValue([]);
+    await run({ json: false, all: false });
+    expect(stdout).toEqual(['No other Qwen Code sessions are running.']);
+  });
+
+  it('emits one JSON object per line with no header', async () => {
+    listLiveSessions.mockResolvedValue([record(), record({ pid: 7 })]);
+    await run({ json: true, all: false });
+
+    expect(stdout).toHaveLength(2);
+    expect(JSON.parse(stdout[0]).pid).toBe(4242);
+    expect(JSON.parse(stdout[1]).pid).toBe(7);
+  });
+
+  it('prints nothing on stdout for an empty JSON listing', async () => {
+    listLiveSessions.mockResolvedValue([]);
+    await run({ json: true, all: false });
+    expect(stdout).toEqual([]);
+  });
+
+  it('excludes this process unless --all is passed', async () => {
+    listLiveSessions.mockResolvedValue([]);
+
+    await run({ json: true, all: false });
+    expect(listLiveSessions).toHaveBeenLastCalledWith({ includeSelf: false });
+
+    await run({ json: true, all: true });
+    expect(listLiveSessions).toHaveBeenLastCalledWith({ includeSelf: true });
+  });
+
+  it('neutralizes control sequences coming from another process record', async () => {
+    listLiveSessions.mockResolvedValue([
+      record({ name: 'evil\r', cwd: '/w/a\nb' }),
+    ]);
+    await run({ json: false, all: false });
+
+    const row = stdout[1];
+    expect(row).not.toContain('');
+    expect(row).not.toContain('\r');
+    expect(row).not.toContain('\n');
+  });
+
+  it('truncates an over-long name instead of breaking the columns', async () => {
+    listLiveSessions.mockResolvedValue([record({ name: 'x'.repeat(80) })]);
+    await run({ json: false, all: false });
+    expect(stdout[1]).toContain('...');
+    expect(stdout[1]).toContain('4242');
+  });
+});

packages/cli/src/commands/sessions/ps.ts

@@ -0,0 +1,152 @@
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `qwen sessions ps` — list the Qwen Code sessions running right now.
+ *
+ * The sibling `qwen sessions list` walks saved transcripts; this walks the
+ * live-process registry, so the two answer different questions: "what have
+ * I worked on" versus "what is running on this machine at this moment".
+ */
+
+import type { CommandModule, Argv } from 'yargs';
+import {
+  listLiveSessions,
+  type SessionRegistryRecord,
+} from '@qwen-code/qwen-code-core';
+import stringWidth from 'string-width';
+import { escapeAnsiCtrlCodes } from '../../ui/utils/textUtils.js';
+import { writeStdoutLine, writeStderrLine } from '../../utils/stdioHelpers.js';
+
+/** Fixed column widths for the human-readable table (exported for tests). */
+export const NAME_COL = 22;
+export const PID_COL = 9;
+export const AGE_COL = 10;
+
+interface PsArgs {
+  json?: boolean;
+  all?: boolean;
+}
+
+/**
+ * Sanitize a value for terminal output.
+ *
+ * `cwd` and `name` originate from another process's on-disk record, so
+ * they are attacker-influenced in exactly the way a log line is: a record
+ * containing an ANSI sequence or a stray `\r` could otherwise repaint or
+ * misalign this table. Mirrors `sessions list`.
+ */
+function sanitize(value: string): string {
+  const stripped = value.replace(/[\r\n\t]/g, '');
+  const escaped = escapeAnsiCtrlCodes(stripped);
+  // eslint-disable-next-line no-control-regex
+  return escaped.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, '');
+}
+
+function padDisplay(str: string, width: number): string {
+  const currentWidth = stringWidth(str);
+  if (currentWidth >= width) return str;
+  return str + ' '.repeat(width - currentWidth);
+}
+
+function truncate(str: string, maxLen: number): string {
+  if (stringWidth(str) <= maxLen) return str;
+  const suffix = maxLen > 3 ? '...' : '';
+  const target = maxLen - stringWidth(suffix);
+  let result = '';
+  let w = 0;
+  for (const char of str) {
+    const cw = stringWidth(char);
+    if (w + cw > target) break;
+    result += char;
+    w += cw;
+  }
+  return result + suffix;
+}
+
+/**
+ * Render an age as a short, human-scannable string.
+ *
+ * A negative delta means the record's clock ran ahead of ours (a paused
+ * VM, a corrected clock). Showing "-3m" reads as a bug, so clamp to 0.
+ */
+export function formatAge(ms: number): string {
+  const seconds = Math.max(0, Math.floor(ms / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+
+function outputHuman(records: SessionRegistryRecord[], now: number): void {
+  writeStdoutLine(
+    padDisplay('NAME', NAME_COL) +
+      padDisplay('PID', PID_COL) +
+      padDisplay('AGE', AGE_COL) +
+      'DIRECTORY',
+  );
+  for (const record of records) {
+    writeStdoutLine(
+      padDisplay(truncate(sanitize(record.name), NAME_COL - 2), NAME_COL) +
+        padDisplay(String(record.pid), PID_COL) +
+        padDisplay(formatAge(now - record.startedAt), AGE_COL) +
+        sanitize(record.cwd),
+    );
+  }
+}
+
+async function handlePs(argv: PsArgs): Promise<void> {
+  let records: SessionRegistryRecord[];
+  try {
+    records = await listLiveSessions({ includeSelf: argv.all ?? false });
+  } catch (err) {
+    writeStderrLine(
+      `Error: failed to read the session registry: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+    process.exit(1);
+    return;
+  }
+
+  const now = Date.now();
+
+  if (argv.json) {
+    for (const record of records) {
+      writeStdoutLine(JSON.stringify(record));
+    }
+    return;
+  }
+
+  if (records.length === 0) {
+    writeStdoutLine('No other Qwen Code sessions are running.');
+    return;
+  }
+
+  outputHuman(records, now);
+}
+
+export const psCommand: CommandModule<unknown, PsArgs> = {
+  command: 'ps',
+  describe: 'List Qwen Code sessions running right now',
+  builder: (yargs: Argv) =>
+    yargs
+      .option('json', {
+        type: 'boolean',
+        describe: 'Output as JSON Lines',
+        default: false,
+      })
+      .option('all', {
+        type: 'boolean',
+        describe: 'Include this process, if it is itself a registered session',
+        default: false,
+      }),
+  handler: async (argv) => {
+    await handlePs(argv);
+  },
+};