@sqaoss/flowy 1.7.0 → 1.9.0

package/src/commands/setup.test.ts

@@ -8,7 +8,7 @@ let mockSpawnSync: ReturnType<typeof vi.fn>
 
 beforeEach(() => {
   mockLoadConfig = vi.fn(() => ({
-    mode: 'saas',
+    mode: 'remote',
     apiUrl: 'https://flowy-ai.fly.dev/graphql',
     apiKey: '',
     client: { name: '' },
@@ -315,6 +315,53 @@ describe('setup command', () => {
     errSpy.mockRestore()
   })
 
+  test('setup remote persists the API key before any later step (save-after-register)', async () => {
+    const mockGraphql = vi.fn().mockResolvedValue({
+      register: {
+        user: {
+          id: 'user_1',
+          email: 'a@b.com',
+          tier: null,
+          createdAt: '2026-06-13T00:00:00Z',
+          graceEndsAt: null,
+        },
+        apiKey: 'flowy_key_persisted',
+        checkoutUrl: null,
+      },
+    })
+    vi.doMock('../util/client.ts', () => ({ graphql: mockGraphql }))
+
+    // The skill install (a step AFTER the key is obtained) blows up hard.
+    // The key must already be on disk by then so the user is never stranded.
+    let keySavedBeforeSkillInstall = false
+    mockSaveConfig.mockImplementation((cfg: { apiKey?: string }) => {
+      if (cfg.apiKey === 'flowy_key_persisted')
+        keySavedBeforeSkillInstall = true
+    })
+    mockSpawnSync.mockImplementation((cmd: string) => {
+      if (cmd === 'npx') {
+        // By the time the (post-register) skill install runs, the key is saved.
+        expect(keySavedBeforeSkillInstall).toBe(true)
+        throw new Error('npx exploded')
+      }
+      return { status: 0, stdout: Buffer.from('') }
+    })
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    const { setupCommand } = await import('./setup.ts')
+    await setupCommand.parseAsync(['remote', '--email', 'a@b.com'], {
+      from: 'user',
+    })
+
+    // The key was saved at least once with the real value before the failure.
+    expect(
+      mockSaveConfig.mock.calls.some(
+        (c) => (c[0] as { apiKey?: string }).apiKey === 'flowy_key_persisted',
+      ),
+    ).toBe(true)
+    errSpy.mockRestore()
+  })
+
   test('setup remote warns when the skill install fails', async () => {
     const mockGraphql = vi.fn().mockResolvedValue({
       register: {

package/src/commands/setup.ts

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process'
 import { Command, Option } from 'commander'
 import { fingerprintKey, loadConfig, saveConfig } from '../util/config.ts'
 import { output, outputError } from '../util/format.ts'
+import { REGISTER } from '../util/operations.ts'
 import { pinnedInstallSpec } from './serve.ts'
 
 export const setupCommand = new Command('setup').description(
@@ -104,16 +105,7 @@ setupCommand
           apiKey: string
           checkoutUrl: string
         }
-      }>(
-        `mutation Register($email: String!, $tier: String) {
-          register(email: $email, tier: $tier) {
-            user { id email tier createdAt graceEndsAt }
-            apiKey
-            checkoutUrl
-          }
-        }`,
-        { email: opts.email, tier: opts.tier },
-      )
+      }>(REGISTER, { email: opts.email, tier: opts.tier })
 
       config.apiKey = data.register.apiKey
       saveConfig(config)

package/src/commands/status.ts

@@ -1,6 +1,7 @@
 import { Command } from 'commander'
 import { graphql } from '../util/client.ts'
 import { output, outputError } from '../util/format.ts'
+import { UPDATE_STATUS } from '../util/operations.ts'
 
 export const statusCommand = new Command('status')
   .description('Update a node status (shorthand)')
@@ -11,14 +12,10 @@ export const statusCommand = new Command('status')
   )
   .action(async (id: string, status: string) => {
     try {
-      const data = await graphql<{ updateNode: unknown }>(
-        `mutation UpdateStatus($id: String!, $status: String) {
-          updateNode(id: $id, status: $status) {
-            id type title status updatedAt
-          }
-        }`,
-        { id, status },
-      )
+      const data = await graphql<{ updateNode: unknown }>(UPDATE_STATUS, {
+        id,
+        status,
+      })
       output(data.updateNode)
     } catch (error) {
       outputError(error)

package/src/commands/task.ts

@@ -3,6 +3,19 @@ import { graphql } from '../util/client.ts'
 import { requireFeature, resolveProject } from '../util/config.ts'
 import { resolveDescription } from '../util/description.ts'
 import { output, outputError } from '../util/format.ts'
+import {
+  ALL_TASKS,
+  BLOCK_TASK,
+  CREATE_TASK,
+  DELETE_NODE,
+  LINK_TASK,
+  LIST_TASKS,
+  READY_TASKS,
+  SHOW_TASK,
+  TASK_DEPS,
+  UNBLOCK_TASK,
+  UPDATE_NODE,
+} from '../util/operations.ts'
 
 export const taskCommand = new Command('task').description(
   'Manage tasks in the active feature',
@@ -27,23 +40,17 @@ taskCommand
         description: opts.description,
         descriptionFile: opts.descriptionFile,
       })
-      const data = await graphql<{ createNode: { id: string } }>(
-        `mutation CreateTask($type: String!, $title: String!, $description: String) {
-          createNode(type: $type, title: $title, description: $description) {
-            id type title description status createdAt
-          }
-        }`,
-        { type: 'task', title: opts.title, description },
-      )
+      const data = await graphql<{ createNode: { id: string } }>(CREATE_TASK, {
+        type: 'task',
+        title: opts.title,
+        description,
+      })
       const taskId = data.createNode.id
-      await graphql(
-        `mutation LinkTask($sourceId: String!, $targetId: String!, $relation: String!) {
-          createEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation) {
-            sourceId targetId relation
-          }
-        }`,
-        { sourceId: taskId, targetId: featureId, relation: 'part_of' },
-      )
+      await graphql(LINK_TASK, {
+        sourceId: taskId,
+        targetId: featureId,
+        relation: 'part_of',
+      })
       output(data.createNode)
     } catch (error) {
       outputError(error)
@@ -67,40 +74,27 @@ taskCommand
       if (opts.ready) {
         const projectId =
           opts.project ?? (opts.all ? undefined : resolveProject()?.id)
-        const data = await graphql<{ readyTasks: unknown[] }>(
-          `query ReadyTasks($projectId: String) {
-            readyTasks(projectId: $projectId) {
-              id type title status createdAt
-            }
-          }`,
-          { projectId: projectId ?? null },
-        )
+        const data = await graphql<{ readyTasks: unknown[] }>(READY_TASKS, {
+          projectId: projectId ?? null,
+        })
         output(data.readyTasks)
         return
       }
 
       if (opts.all) {
-        const data = await graphql<{ nodes: unknown[] }>(
-          `query AllTasks($type: String!) {
-            nodes(type: $type) {
-              id type title status createdAt
-            }
-          }`,
-          { type: 'task' },
-        )
+        const data = await graphql<{ nodes: unknown[] }>(ALL_TASKS, {
+          type: 'task',
+        })
         output(data.nodes)
         return
       }
 
       const featureId = requireFeature()
-      const data = await graphql<{ descendants: unknown[] }>(
-        `query ListTasks($nodeId: String!, $relation: String!, $maxDepth: Int) {
-          descendants(nodeId: $nodeId, relation: $relation, maxDepth: $maxDepth) {
-            id type title status createdAt
-          }
-        }`,
-        { nodeId: featureId, relation: 'part_of', maxDepth: 1 },
-      )
+      const data = await graphql<{ descendants: unknown[] }>(LIST_TASKS, {
+        nodeId: featureId,
+        relation: 'part_of',
+        maxDepth: 1,
+      })
       const tasks = data.descendants.filter(
         (n: unknown) => (n as { type: string }).type === 'task',
       )
@@ -120,20 +114,7 @@ taskCommand
         node: Record<string, unknown>
         blockedBy: unknown[]
         blocks: unknown[]
-      }>(
-        `query ShowTask($id: String!) {
-          node(id: $id) {
-            id type title description status metadata createdAt updatedAt
-          }
-          blockedBy: edges(nodeId: $id, relation: "blocks", direction: "incoming") {
-            id type title status
-          }
-          blocks: edges(nodeId: $id, relation: "blocks", direction: "outgoing") {
-            id type title status
-          }
-        }`,
-        { id },
-      )
+      }>(SHOW_TASK, { id })
       output({
         ...data.node,
         blockedBy: data.blockedBy,
@@ -170,11 +151,7 @@ taskCommand
       }
       if (opts.metadata != null) variables.metadata = opts.metadata
       const data = await graphql<{ updateNode: unknown }>(
-        `mutation UpdateNode($id: String!, $title: String, $description: String, $metadata: String) {
-          updateNode(id: $id, title: $title, description: $description, metadata: $metadata) {
-            id type title description status metadata createdAt updatedAt
-          }
-        }`,
+        UPDATE_NODE,
         variables,
       )
       output(data.updateNode)
@@ -189,12 +166,7 @@ taskCommand
   .argument('<id>', 'Task ID')
   .action(async (id: string) => {
     try {
-      const data = await graphql<{ deleteNode: boolean }>(
-        `mutation DeleteNode($id: String!) {
-          deleteNode(id: $id)
-        }`,
-        { id },
-      )
+      const data = await graphql<{ deleteNode: boolean }>(DELETE_NODE, { id })
       output({ deleted: data.deleteNode })
     } catch (error) {
       outputError(error)
@@ -208,14 +180,11 @@ taskCommand
   .argument('<id2>', 'Blocked task ID')
   .action(async (id1: string, id2: string) => {
     try {
-      const data = await graphql<{ createEdge: unknown }>(
-        `mutation BlockTask($sourceId: String!, $targetId: String!, $relation: String!) {
-          createEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation) {
-            sourceId targetId relation createdAt
-          }
-        }`,
-        { sourceId: id1, targetId: id2, relation: 'blocks' },
-      )
+      const data = await graphql<{ createEdge: unknown }>(BLOCK_TASK, {
+        sourceId: id1,
+        targetId: id2,
+        relation: 'blocks',
+      })
       output(data.createEdge)
     } catch (error) {
       outputError(error)
@@ -229,12 +198,11 @@ taskCommand
   .argument('<id2>', 'Blocked task ID')
   .action(async (id1: string, id2: string) => {
     try {
-      const data = await graphql<{ removeEdge: boolean }>(
-        `mutation UnblockTask($sourceId: String!, $targetId: String!, $relation: String!) {
-          removeEdge(sourceId: $sourceId, targetId: $targetId, relation: $relation)
-        }`,
-        { sourceId: id1, targetId: id2, relation: 'blocks' },
-      )
+      const data = await graphql<{ removeEdge: boolean }>(UNBLOCK_TASK, {
+        sourceId: id1,
+        targetId: id2,
+        relation: 'blocks',
+      })
       output({ removed: data.removeEdge })
     } catch (error) {
       outputError(error)
@@ -248,14 +216,7 @@ taskCommand
   .action(async (id: string) => {
     try {
       const data = await graphql<{ blockedBy: unknown[]; blocks: unknown[] }>(
-        `query TaskDeps($id: String!) {
-          blockedBy: edges(nodeId: $id, relation: "blocks", direction: "incoming") {
-            id type title status
-          }
-          blocks: edges(nodeId: $id, relation: "blocks", direction: "outgoing") {
-            id type title status
-          }
-        }`,
+        TASK_DEPS,
         { id },
       )
       output({ id, blockedBy: data.blockedBy, blocks: data.blocks })

package/src/commands/tree.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 
 describe('tree command', () => {
   test('exports a flat command with id argument and depth option', async () => {
@@ -6,4 +6,92 @@ describe('tree command', () => {
     expect(treeCommand.name()).toBe('tree')
     expect(treeCommand.commands).toHaveLength(0)
   })
+
+  test('exposes a --relation option defaulting to part_of', async () => {
+    const { treeCommand } = await import('./tree.ts')
+    const relationOpt = treeCommand.options.find((o) => o.long === '--relation')
+    expect(relationOpt).toBeDefined()
+    expect(relationOpt?.defaultValue).toBe('part_of')
+  })
+
+  describe('action', () => {
+    beforeEach(() => {
+      vi.resetModules()
+    })
+
+    afterEach(() => {
+      vi.restoreAllMocks()
+      vi.unstubAllEnvs()
+    })
+
+    test('sends the SUBTREE op with the relation filter and renders depth/relation', async () => {
+      const calls: Array<{ query: string; variables: unknown }> = []
+      vi.doMock('../util/client.ts', () => ({
+        graphql: vi.fn(async (query: string, variables: unknown) => {
+          calls.push({ query, variables })
+          return {
+            subtree: [
+              {
+                id: 'feat_1',
+                type: 'feature',
+                title: 'F1',
+                status: 'draft',
+                parentId: 'proj_1',
+                depth: 1,
+                relation: 'part_of',
+              },
+            ],
+          }
+        }),
+      }))
+      const outputs: unknown[] = []
+      vi.doMock('../util/format.ts', () => ({
+        output: vi.fn((data: unknown) => outputs.push(data)),
+        outputError: vi.fn(),
+      }))
+
+      const { SUBTREE } = await import('../util/operations.ts')
+      const { treeCommand } = await import('./tree.ts')
+      await treeCommand.parseAsync(['proj_1'], { from: 'user' })
+
+      expect(calls).toHaveLength(1)
+      expect(calls[0]!.query).toBe(SUBTREE)
+      expect(calls[0]!.variables).toMatchObject({
+        nodeId: 'proj_1',
+        relation: 'part_of',
+      })
+
+      const rendered = outputs[0] as Array<Record<string, unknown>>
+      expect(rendered[0]).toMatchObject({
+        id: 'feat_1',
+        parentId: 'proj_1',
+        depth: 1,
+        relation: 'part_of',
+      })
+    })
+
+    test('passes an overridden relation through to the op', async () => {
+      const calls: Array<{ variables: unknown }> = []
+      vi.doMock('../util/client.ts', () => ({
+        graphql: vi.fn(async (_query: string, variables: unknown) => {
+          calls.push({ variables })
+          return { subtree: [] }
+        }),
+      }))
+      vi.doMock('../util/format.ts', () => ({
+        output: vi.fn(),
+        outputError: vi.fn(),
+      }))
+
+      const { treeCommand } = await import('./tree.ts')
+      await treeCommand.parseAsync(['task_1', '--relation', 'blocks'], {
+        from: 'user',
+      })
+
+      expect(calls[0]!.variables).toMatchObject({
+        nodeId: 'task_1',
+        relation: 'blocks',
+      })
+    })
+  })
 })

package/src/commands/tree.ts

@@ -1,21 +1,24 @@
 import { Command } from 'commander'
 import { graphql } from '../util/client.ts'
 import { output, outputError } from '../util/format.ts'
+import { SUBTREE } from '../util/operations.ts'
 
 export const treeCommand = new Command('tree')
   .description('Show subtree from any entity')
   .argument('<id>', 'Root node ID')
   .option('--depth <n>', 'Max depth', '10')
+  .option(
+    '--relation <relation>',
+    'Edge relation to follow (e.g. part_of, blocks)',
+    'part_of',
+  )
   .action(async (id: string, opts) => {
     try {
-      const data = await graphql<{ subtree: unknown[] }>(
-        `query Subtree($nodeId: String!, $maxDepth: Int) {
-          subtree(nodeId: $nodeId, maxDepth: $maxDepth) {
-            id type title status
-          }
-        }`,
-        { nodeId: id, maxDepth: Number.parseInt(opts.depth, 10) },
-      )
+      const data = await graphql<{ subtree: unknown[] }>(SUBTREE, {
+        nodeId: id,
+        relation: opts.relation,
+        maxDepth: Number.parseInt(opts.depth, 10),
+      })
       output(data.subtree)
     } catch (error) {
       outputError(error)

package/src/commands/whoami.test.ts

@@ -9,7 +9,7 @@ beforeEach(() => {
   mockOutput = vi.fn()
   mockOutputError = vi.fn()
   mockLoadConfig = vi.fn(() => ({
-    mode: 'saas',
+    mode: 'remote',
     apiUrl: 'https://flowy-ai.fly.dev/graphql',
     apiKey: 'flowy_secret_abcdef0123456789',
     client: { name: '' },
@@ -42,6 +42,16 @@ beforeEach(() => {
     return {
       loadConfig: mockLoadConfig,
       fingerprintKey: actual.fingerprintKey,
+      requireRemoteMode: (commandName: string) => {
+        const cfg = (mockLoadConfig as unknown as () => { mode: string })()
+        if (cfg.mode === 'local') {
+          const err = new Error(
+            `"flowy ${commandName}" is only available in remote mode. The active mode is local mode.`,
+          ) as Error & { code?: string }
+          err.code = 'LOCAL_MODE'
+          throw err
+        }
+      },
     }
   })
 })
@@ -100,4 +110,27 @@ describe('whoami command', () => {
     const query = mockGraphql.mock.calls[0]?.[0] as string
     expect(query).toContain('graceEndsAt')
   })
+
+  test('whoami errors cleanly in local mode without hitting the server', async () => {
+    mockLoadConfig.mockReturnValue({
+      mode: 'local',
+      apiUrl: 'http://localhost:4000/graphql',
+      apiKey: '',
+      client: { name: '' },
+      projects: {},
+    })
+
+    const { whoamiCommand } = await import('./whoami.ts')
+    await whoamiCommand.parseAsync([], { from: 'user' })
+
+    // No GraphQL call against the local server.
+    expect(mockGraphql).not.toHaveBeenCalled()
+    expect(mockOutput).not.toHaveBeenCalled()
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringMatching(/local mode/i),
+        code: 'LOCAL_MODE',
+      }),
+    )
+  })
 })

package/src/commands/whoami.ts

@@ -1,19 +1,19 @@
 import { Command } from 'commander'
 import { graphql } from '../util/client.ts'
-import { fingerprintKey, loadConfig } from '../util/config.ts'
+import {
+  fingerprintKey,
+  loadConfig,
+  requireRemoteMode,
+} from '../util/config.ts'
 import { output, outputError } from '../util/format.ts'
+import { WHOAMI } from '../util/operations.ts'
 
 export const whoamiCommand = new Command('whoami')
   .description('Show current user info')
   .action(async () => {
     try {
-      const data = await graphql<{ whoami: Record<string, unknown> }>(
-        `query Whoami {
-          whoami {
-            id email tier createdAt graceEndsAt
-          }
-        }`,
-      )
+      requireRemoteMode('whoami')
+      const data = await graphql<{ whoami: Record<string, unknown> }>(WHOAMI)
       // Surface a non-reversible fingerprint of the configured key so a human
       // can confirm *which* credential is active without exposing it (F35).
       output({